An open letter to Richard M. Stallman | Hacker News Reader

An open letter to Richard M. Stallman

elizabeths-blargh.blogspot.com

163 pointsDiabloD3170 comments

RMS doesn't care about "open source", something he will gladly remind you of if you use that phrase in his presence.

His position in this matter is long-standing and consistent with his principles. That's how you have to understand him: a man of principles surrounded by enemies.

Look at OS X, why does it use such an ancient version of Bash? Why is apple so afraid of the GPLv3? It's not just an oversight. The GPLv3 provides strong patent protection for its users and Apple uses patents as a weapon. An example of this powerful weapon was Apple's conspiracy to suppress wages by threatening companies who poached Apple employees with patent suits.

Imagine you make a tool and someone proposes making a change to that tool that would be potentially useful to slavers, people who enslave other people. This makes you hesitate. Pointing out that people already use similar tools for slavery probably wouldn't make you change your mind.

"enemies" or merely people who politely disagree with his definition of free?

>a man of principles surrounded by enemies.

Or a zealot who sees enemies everywhere.

Neither of the above. It's no secret what RMS is doing here, and he's fully aware of the context and way in which he is perceived. Some people like to think that he doesn't care, and they have it almost exactly backwards.

The most extreme person on any issue is always ridiculed and disregarded by a large chunk of any community, regardless of whether this is correct or not. People like middle things. RMS's objective is to be the most extreme person, and to drag that position so far over that no other free software effort can be ridiculed or ignored in this fashion.

You haven't chosen to be the middle ground here. RMS has chosen to make you the middle ground, because that's where he wanted it to be, so he hiked all the way over there to plant his flag in order to move the middle. A few decades later, it looks like that worked.

I've never before heard the theory that Richard Stallman is consciously trying to move the Overton Window. http://en.wikipedia.org/wiki/Overton_window

The Occam's Razor http://en.wikipedia.org/wiki/Occam%27s_razor explanation is that Stallman genuinely believes his positions are correct.

The FSF as an window moving org is a view I heard expressly presented at their annual members conference a number of years ago. At the time the discussion, I believe, was in the context of the very active "defective by design" campaign, and in response to some views that a more moderate response to DRM (like that taken by other groups like the EFF) might be more effective.

This isn't incompatible with earnestly believing the views. All of us hold principles that exist on a spectrum and can pragmatically decide how we apply them without necessarily compromising them, in order to optimize for progress of certain kinds on certain time-frames with certain costs.

An example of this, RMS's positions have become stronger as free software as matured: IIRC GNU was originally developed on Sun boxes; but RMS would never use an outright proprietary OS today. Early free software system he used had non-free firmware or other blobs, but he advocates strongly against that today. There are a set of strong ideals, sure, but the amount of compromise someone holding them should optimally take depends on the overall state of the world and their position to influence it.

The notion of software freedom as a human rights issue can be quite foreign to people and without someone taking it very seriously some, especially those who have mostly regarded technology as a black box, can too easily dismiss it.

Never attribute to malice that which is adequately explained by stupidity. - Hanlon's Razor - https://en.wikipedia.org/wiki/Hanlon%27s_razor

It is not that his doing didn't turn out to be intelligent, but his intent almost certainly wasn't.

> IIRC GNU was originally developed on Sun boxes

Actually it was an unused small Vax (730?) running BSD. It was unused because it was in the AI lab, where we all used lispms or the PDP-10s upstairs (don't get me wrong -- some of the non-AI folks in computer science used unix).

I don't even remember why that machine was there in the first place -- it seemed so peculiar to have a machine like that in the first place. 8-bit bytes and the small, 32-bit word didn't feel like the future at the time (hah!). It was stuck in a small machine room.

While the 730 and the Sun-1 were available by the time the GNU project was started, I strongly suspect that an 11/750 was the original machine.

(I wasn't running GNU (emacs) until 1984, and didn't contribute to GCC until 1987.)

Indeed, now you mention it it was a 750.

Good thing for my self image I put that question mark in there.

Yeah, I suspected so.

DEC had a problem with selling MIT and other non-profits hardware at a discount, the US Federal government demands Most Favored Customer prices (https://en.wikipedia.org/wiki/Most-Favoured-Customer_Clause), so I heard they came up with a not so desirable configuration of a Vax 11-750, a RK07 disk drive, and a VAXstation 100 display, which was a 68000 with a megabyte or so of memory and a very fast connection to the VAX.

Which I was also told had an outsized influence on the X architecture, its assumptions of a fast connection to a relatively dumb display, very much the opposite of what developed in longer term.

Which was a motivation for Sun's NeWS, which sent interactive PostScript to the display https://en.wikipedia.org/wiki/NeWS We aren't using it/you've never heard of it because of the "MIT License" vs. Sun wanting $100K to even give you a taste of NeWS.

Agreed completely and having met the man, can confirm that every cause needs an extremist and he is better at it than any one i can imagine. At some point in your life you have to decide to refuse compromise.

I was sat beside the venerable and lovely Bruce Perens at a conference at which RMS was talking and we had this chat. Bruce is too pragmatic to hold people to account.

People who know politics will tell you the same for being dragged to the middle by opposing parties.

> You haven't chosen to be the middle ground here. RMS has chosen to make you the middle ground, because that's where he wanted it to be, so he hiked all the way over there to plant his flag in order to move the middle.

I'm sorry: that's a good strategy, but I have known RMS since the late '70s (since back when he still had short hair!) and that is not has strategy. He is earnest, even when it is to his detriment.

Funny anecdote in this regard: I had never really met anyone quite so dogmatic, passionate, principled and resolute as RMS (you can say that whether you agree with him or not -- though roughly, I of course do agree with him). I used to consider him to be a uniquely polarizing figure. Anyway, in the 80s I had a girlfriend who wasn't in computing and had never heard of him. He came out to visit me in California. When she met him, she just commented, "oh, one of those guys."

WTF? Turned out the two of them had grown up in the same neighborhood in the Bronx. She said the 'hood was "full of guys just like him" (although presumably they were obcessed about some other topics). Sadly her family had since moved elsewhere so I never collected empirical confirmation.

I have no idea what your then-girlfriend meant by one of those guys. Or whether the Bronx hood was full of obsessed guys in the '70s?? I am genuinely curious, though.

FWIW I doubt she meant anything judgmental by her remark (approval or disapproval or whatever).

I think she just meant that she saw lots of RMSs growing up: a guy, perhaps a product of his time, who had a certain intensive attitude on a position, a taste for the extremist polemic, strongly held beliefs anchored in moral fervor etc. Also accent, body language, dress, etc. Surely similar people can be found everywhere, but in her case she meant that in the 60s, 70s and 80s Bronx you could get off the train and see bunch of guys that would look to her just like him. She grew up in the same cultural broth, even if it manifested itself differently -- but yes she was and is intense.

I haven't forgotten that simple sentence because it changed something for me: RMS sure can come off as being completely sui generis but really he (like everyone, whether a lowly ant like me or an Issac Newton or Barbara McClintock) is a product not only of self creation but also of his context and upbringing. And realizing that has helped me grow and change (or accept that some things are harder to change than others) over the past few decades.

> [RMS is] fully aware of the context and way in which he is perceived. RMS's objective is to be the most extreme person, and to drag that position so far over that no other free software effort can be ridiculed or ignored in this fashion.

This is an intriguing theory. But I find it difficult to believe that RMS is playing such a deep game when so much of his communication unrelated to free software principals -- e.g. his contract rider [1] -- comes across to so many people as tone-deaf.

[1] https://groups.google.com/a/mysociety.org/forum/#!msg/mysoci...

Urgh, that should be "principles".

The problem is that, at this point, the FLOSS community increasingly treats RMS as damage and routes around him.

without the zealots the pograms of distributed piss taking will find you

> Imagine you make a tool and someone proposes making a change to that tool that would be potentially useful to slavers, people who enslave other people. This makes you hesitate. Pointing out that people already use similar tools for slavery probably wouldn't make you change your mind.

I know you're being hyperbolic here to represent RMS's take on the issue (or at least that's how I'm reading it), but I'm not sure the analogy makes sense.

If I were to reinterpret it using the same terms, the counter-argument isn't that "people already use similar tools for slavery", it is that "slavers" wouldn't care what you did with your tool because they're already having no trouble commiting their crimes with similar tools, and your new tool could be used in perfectly legitimate ways to support your own position which includes combating slavery.

His position doesn't make any sense, though. It only made sense as long as LLVM didn't exist, but now that it does, it only hurts GCC. Anybody who wants to incorporate Clang or LLVM into a proprietary project already can, so absolutely nothing is gained by crippling GCC to make it less useful to those people.

All this is covered in the letter, in fact. If his principles lead him to completely ignore the real world impact of his decisions, his principles are not good ones, and not something to be admired.

I do not believe you can claim that Stallman does not understand the real world impacts of license decisions in complex software ecosystems: the LGPL is an example, which is designed to be used when entering a realm with existing high-quality commercial competition, and in the case of Ogg Vorbis Stallman actually recommended the use of a BSD license as it made more sense as the real battle was against MP3, not between implementations of Vorbis.

http://lwn.net/2001/0301/a/rms-ov-license.php3

I'm not saying, though, that he's unaware of the real world impacts. I'm saying that he doesn't care about them (in this case). He is a smart man, and a visionary, and believe it or not, I have a great deal of respect for him, in large part because of how prophetic he's been regarding some of the troubling developments of recent years. That said, he doesn't appear to care about the impact of this decision, which is to drive everyone to clang/llvm.

If no one forks gcc to keep it from becoming technically inferior, then in ten years, we'll just have another open source compiler monoculture, but this time it will be clang/llvm.

(Edit: forgot an important word.)

I rather have the impression that the development of IDEs ran past Mr Stallman - he didn't witness the development in refactoring, code completion etc. since these features are essentially implement in commercial IDEs (which he despises). So he just doesn't know anything about how useful (or not) these features are. He learned and did programming "in the old way" and sticked to that.

It doesn't have to be like that. I suggested elsewhere in that thread that emacs maintainers should use llvm for what they need, since it can already provide that service. This would require further down the road to have Gcc match llvm feature-wise (except maybe that feature), so that compilation of code accepted by llvm would be possible with Gcc.

I'm almost certain that RMS would veto the use of LLVM. He clearly views LLVM as an enemy of 'freedom'.

There's ethic, and there is practicalities. RMS stands by the former, while many engineers think mostly about the later. I wouldn't say that thinking ethically is a bad thing, but it may hamper things, because it usually deals very poorly with a situation already unethical in nature.

There are more than 7 billions people on Earth, but barely enough resources to content everyone. Pushing resource extractions will damage the ecosystem, but not doing so will provoke millions of deaths. Preserving nature is a laudable goal IMHO, wouldn't you agree?

>it usually deals very poorly with a situation already unethical in nature.

Allowing code completion and complex refactoring in emacs is "unethical in nature"?

He seems to think that gcc could output a incomplete AST that could be used to implement all necessary emacs features without being usable for compiler backends. The other emacs maintainers seem to think that is fighting with one hand tied behind their back.

For RMS, allowing non free code to be derived from free code is unethical, it goes against all the ideal of his movement. Indeed, from your standpoint, the thing he is fighting against seems trivial, but there are deeper consequences.

For RMS, non-free code period is unethical, regardless of its derivation.

His position makes complete sense then, because proprietary software developers you just incorporate Clang and ignore GCC. It might just be the case free software advocates and those who release under the GPL do not want to trade ethics for market share.

That is a better situation than GCC being the only show in the house and every company trying to find a way to break the GPL around GCC so they can reuse it without releasing source.

We aren't just talking about proprietary software developers using llvm. The projects most hurt by GCC being crippled by design are those like emacs that want to do more advanced things using GCC AST but can't. Emacs is being deliberately harmed to prevent other proprietary developers doing something they can already do anyway.

If you are saying GPL advocates believe they are correct to deliberately cripple their software for political reasons, then what kind of lesson do you think that is teaching an entire generation of CS postgrads and academics who are forced to use LLVM for their work because RMS thinks they shouldn't be allowed to do compiler research using Free Software. The damage to mindshare and reputation is huge here. To be honest I'm not sure it's even recoverable at this point. To a lot of people GNU software is turning into "stuff you don't use because it's crippled for political reasons and they want to control what you can do with software". Very morally pure I'm sure, but also suicidal.

In what way is Emacs being "deliberately harmed"?

It has worse code completion and refactoring support for C and C++ than it should have. Emacs users are forced to switch to other tools (like proprietary IDEs or LLVM based tools) when they need to do complex refactoring to c++ codebases. It could be improved (should have been years ago) but RMS has stated that he would block the inclusion of code to do those things if they use a GCC plugin that exports the full AST.

This is all discussed in the original mailing list thread and it's why one of the core emacs devs suggested forking.

See the thread that prompted this: https://lists.gnu.org/archive/html/emacs-devel/2015-01/msg00...

Basically, an Emacs maintainer thinks that this gcc restriction is so harmful to important emacs features that he would be willing to "consider a fork"

Why not reverse the argument? If llvm can already be used for that sort of task, why not simply use it in place of Gcc for that very precise task? I'm pretty sure RMS would not mind it as much as opening gcc's AST, and he would certainly embrace the idea of making Gcc able to match llvm feature wise to make sure that whatever becomes possible in emacs is handled at compilation by Gcc.

Yes, you'd think that, wouldn't you... But the only reason for this discussion is that RMS had already prevented the inclusion of clang-based tools in the Emacs code base. He thinks it'd undermine GCC, and by extension his cause.

Hmmm, Charybde and Scylla. There's no solution I suppose, or maybe just go by what RMS wants: produce a data structure for the necessary data for the simplest possible improvement, then define a more involved data structure for a more ambitious feature, and reiterate again and again, until the data structure becomes isomorphic to what Gcc deals with. No need to actually code all these steps, just specifying them should help RMS understand that it's inevitable at some point.

RMS is unwavering.

He is an ethical fixed point combinator if you will, the fixed point combinator of FOSS. Like a lighthouse on a rocky shore he'll perpetually shine his light to keep you away from the rocks of proprietary software.

I'm not even sure how much of this is tongue in cheek.

> Imagine you make a tool and someone proposes making a change to that tool that would be potentially useful to slavers, people who enslave other people. This makes you hesitate.

No, it really doesn't. "Bad people might use it to do something I don't approve of" is a terrible rationale for not creating something, mostly because it's almost always true. Strong crypto is great for terrorists. Psychology research is wonderful for propagandists in dictatorships. Unlocked cell phones are very useful for drug trafficking rings.

If we, as a species, refused to innovate when we weren't sure of the consequences, we would still be arguing about whether fire was a good idea.

This may sound like a reductio at absurdum, but if that innovation threaten your ability to survive, you will be very reluctant to research it, won't you? Gcc has been the very foundation of gnu, it's the cornerstone of the whole ecosystem: you cannot run Linux (or hurd) without compiling it first. Imagine you'd be commissioned to the fabrication of a virus immune to all known forms of treatments for the purpose of using it to hotpatch cancerous cells. Obviously this tech could have much more dangerous applications, and without a way to disable it, noone would stand a chance. In that scenario, wouldn't you try to reduce this virus' immunity to the minimum needed for its planned usage?

Being used for bad purposes is different than having a net negative effect. E.g. if you are making weapons or something like that.

A lot of people do this. Some people do refuse to work on military technologies. Even Google declared it wouldn't produce anything for the military with the robotics startups it's acquired. Some of the scientists who worked on the Manhattan project later regretted it.

If you really do believe the thing you are working on will have a net negative effect on the world than maybe you shouldn't work on it.

Military weapons have few non-violent uses. ASTs have many uses other than assisting proprietary IDEs (for example, allowing emacs to complete with proprietary IDEs on a level playing field).

It's more akin to refusing to manufacture kitchen knives and forcing all the chefs in your kitchen to chop things with spoons. Even though anybody who wants to stab people already has easy access to very big and sharp knives just by stepping into any other kitchen in the world. Also lots of your chefs keep sneaking over to the kitchen over the road to chop things and no newly trained chef wants to work in your kitchen because they think only chopping with spoons is stupid and only done by crazy religious old men with big beards. OK this metaphor is getting pretty stretched now.

The original OP was not adressing things that can have a dialetic good/bad use like a knife, but things that can only have a bad effect, like guns for instance, they will only be used to hurt or take lives, you cant cook with a gun..

In his manhattan project example, produce atomic bombs will have only one bad consequence, same with guns, but not the same as a knife.

I don't think the issue is just allowing proprietary IDEs to interface with Gcc; I think there are deeper issues at play.

Also, I wouldn't say that he's forcing anyone to chop things, he's more likely saying "let's make dishes from recipes which don't require chopping things", but his cooks are still used to chopping. Is there really an alternative to strong "intellisense" and refactoring abilities in IDEs for efficient development ? I don't know. I personally feels that this is a necessary step. Maybe RMS, with his experience of AI research (iirc), has a different view.

> Maybe RMS, with his experience of AI research (iirc), > has a different view.

RMS primarily uses C and Lisp. Lisp source code is a tree already. And C is so simple you can get by with tags and such.

If he was a C++/Java/C# programmer (which he is not) he may have a different feeling on the importance of the AST relative to the risk of Microsoft using gcc with VisualStuio to offer advanced features while by-passing the GPL.

Of course, but even with lisp you can't (programmatically) work on the code without having that code representation. If it's trivial, then there's no harm in opening it, but RMS thinks otherwise, so there must be something else.

A better analogy would be organic vs. non-organic food, where the non-organic food can get you much more consistent and cheaper results, but leads to a lot of negative externalities whose effects compound over time.

One is focused on short-term quarterly profit, the other on long-term social goods.

The maintainers of pf (bsd license) were once hosed by Apple, understandable that rms doesn't want to enable easy future gcc front end proprietary software.

Henning Brauer: "We have no problem with them using our code but we do not appreciate that they subjected it to the Apple Public Source License. They introduce some interesting ideas such as a ref count of how many times PF has been enabled or disabled but we are unable to use their implementation. Furthermore, the Apple Public Source License introduces contract law to an environment that only relied on copyright law. This is unfortunate."

I think “hosed by Apple” is an unjustified summary. More like, “the maintainers of pf released their code under a very permissive license, and then one or more of them was unhappy when someone else took their license terms at face value and used their code in strict accordance with those terms.”

If what the pf maintainers really wanted was to use a GPLv2 type license, and instead they used BSD, and now are unhappy about the consequences, I can’t see how that’s Apple’s fault.

This. Henning doesn't understand licensing very well.

> Look at OS X, why does it use such an ancient version of Bash? Why is apple so afraid of the GPLv3? It's not just an oversight. The GPLv3 provides strong patent protection for its users and Apple uses patents as a weapon. An example of this powerful weapon was Apple's conspiracy to suppress wages by threatening companies who poached Apple employees with patent suits.

The Linux kernel developers also oppose the GPLv3. Are they enemies as well?

dmm didn't say anyone and everyone opposing GPLv3 are bad, he's just giving an example of how NOT using GPLv3 can be used to punish or coerce behaviour against the principles RMS stands for.

Yes.

To RMS? Probably.

The majority of programmers use free software for practical reasons and are willing to "compromise" with the desires of proprietary software companies.

For RMS free software is an ideological struggle. In his ideal world proprietary software wouldn't exist.

Its important to note, also, that for RMS the struggle is against non-free software, which is at times in conflict with what people who see free software as an ideological struggle to promote free software would view as desirable.

Its not just that its an ideological struggle for RMS, its what RMS sees that struggle as being about which can divide hi from others.

The problem is that the only way to win against non-free software is to provide viable free-software alternatives. Free software cannot win on ideology alone, it _has_ to provide the features users need.

"The GPLv3 provides strong patent protection for its users and Apple uses patents as a weapon"

First, GPLv3's patent provisions are not particularly strong compared to other open source licenses.

Second, this has nothing to do with anything, and certainly isn't a reason for Apple avoidance of GPLv3.

Apple was almost unilaterally concerned with the installation information requirements in GPLv3 (that would require providing signing keys and allowing modifications/reverse engineering), not the patent provisions. They said so, multiple times in the various working groups/mailing lists/etc for GPLv3. Heck, APSL, The Apple Public Source License, version 2.0, which apple released tons of source under, predates GPLv3 by 4 years (2003 vs 2007), and happily grants patents.

http://www.opensource.apple.com/license/apsl/

Apple, for the record, was willing to give the GCC project all of the code to LLVM under the GPL and non-assert any patents (and to my knowledge, Apple has not filed patents on any part of LLVM that they have contributed to publicly)

Apple has also contributed to tons of Apache licensed code and similar code that requires contributors grant patent licenses.

I work for Google, and have personally seen them contribute code to our projects with patent licenses (though admittedly, not as much as they used to). Additionally, I worked on both LLVM and GCC, and was involved directly in the various plans WRT to LLVM and GCC merging. Same with GPLv3 stuff, etc.

There are plenty of things to rake Apple over the coals over, and plenty of reasons why Apple disliked GPLv3, but what you cite simply isn't one of them.

> rake Apple over the coals over

You spend a lot of time negating dmm's comments about Apple, when most of his post was about pools of power controlling or attempting to control a given bit of software. Granted, Apple spends a bit of time doing this very thing quite frequently and most people seem cool with it (because it's so easy!), so I'm curious why you are so set on defending it?

Because misinformation is misinformation, and i'm not a fan of sitting by and letting it drop, whether it's happening to me, my colleagues, or even companies i don't particularly like personally, but happen to know facts about.

Particularly when this is used as the lead-in and part of a strategy of supporting an argument.

In fact, i'll point out that RMS is actually very good about this stuff himself. If his position is based on factually incorrect info, and you correct it, he will often immediately change his position.

Thanks, I was wrong about apples reason not to use the gplv3.

In this case, though, the tool is trivial to make. Any "slaver" that wants it can easily make it themselves. Foregoing making and using that tool for use in Emacs does nothing whatsoever to impede, dissuade, or discourage "slavers" from getting the tool. It just makes it much harder to give Emacs some features that many of its competitors have.

> RMS doesn't care about "open source"

Apparently, he also doesn't care about free software enough either, since he apparently prefers users to switch to something they can _use_ than allow provision of the functionality they need, on the basis that the same functionality could be used by non-free software.

Stallman doesn't care if clouty companies fork GCC and add features he doesn't like. This is a freedom granted to all of us.

The point is Stallman himself would rather see upstream GCC become an inferior tool, or fall in to disuse and obscurity, than act in any way which, on balance, would mostly just enable proprietary software. We're talking about a man here who said (just less than two weeks ago at 31C3) that stealing food to survive, given no third option, was more morally justifiable than writing proprietary code for a living.

The author of this blog clearly doesn't understand this world view because they've set themselves up with a strawman to knock down, assuming it merely boils down to a strategic error on Stallmans part with regard to what is the most effective means by which to ensure the best products out there are FOSS.

The problem is that Stallman has painted himself in a corner here. On the one hand, he says: don't use LLVM/Clang, it's dangerous, use GCC instead; on the other hand, he says, no, you cannot add to GCC the features that you would need to use it instead of LLVM/Clang. The net result is that Emacs will not have a set of features that are _essential_ for development of C++ software, which in turn drives people away from using Emacs to other IDEs.

He's not furthering the cause of GNU and the FSF, he is not promoting free software, he is _driving people away from it_.

What's the point of making all those talks about the importance of free software, if you then actively _prevent_ free software from being useful?

Software exist because it has a use, otherwise it's just a worthless exercise in futility.

I see a thread were RMS seems unusually patient and polite: https://lists.gnu.org/archive/html/emacs-devel/2015-01/msg00...

And a blog post by someone who's name seems to appear nowhere in the GCC SCM history, threating a fork.

It's not clear to me whats going on here.

The maintainer of Emacs, Stefan, actually started all of this forking talk.

I am a strong supporter of the GPL and its relatives, and of copyleft free software in general. Clang is going to replace the GCC in time because of the superiority of its design, and I think it's a shame it's not under the GPL.

But I think RMS is wrong here. I would never initiate a free project under a license that isn't strictly copyleft, but I also would never intentionally limit the usefulness and expressiveness of a program I created because that output could be useful for non-free software. If he doesn't want the GCC to be useful for non-free software, why is there language preventing compilation from falling under the linking clause of the GPL? Maybe I just don't have a strong enough understanding of the context here.

That said, this "open letter" is quite absurd! Not even getting into the really dubious substance of it: why such hostility? why such trumpeting? why not respond on the mailing list?

> I think it's a shame it's not under the GPL.

If Clang is under a permissive non-copyleft license, can't you just fork/relicense it under the GPL? And then build improvements on the GPL version? It's not very nice or sporting, but counterintuitively, it would help demonstrate why copyleft is important.

I'm not a lawyer, but from what I understand - you can't simply re-license the existing code, because the copyright does not belong to you. You could add your own GPL-licensed improvements to the code though, in which case consumers would need to abide by the terms of the GPL (because they're consuming both the original BSD-licensed code and your GPL-licensed code).

It is MIT based, which is GPL compatible, so yeah, you can make GPL only changes in your own Clang fork and if anyone uses your changes in their own Clang fork regardless of what all the other code is licensed under they are now beholden to the GPL.

Which is why I really don't get the doom and gloom around GCC here. Architecturally LLVM makes huge sense. If you are a free software advocate it makes all the sense in the world as well to continue developing GCC until such a time where the technical merits of LLVM are too great to ignore.

And then you just release GNULVM as a fork of LLVM under the GPL and continue on your merry way. Merge in all the good stuff from GCC and upstream patches from LLVM into your working tree and get the best of both worlds, because as long as new contributions are GPL you are not enabling the deprivation of user freedoms.

> If you are a free software advocate it makes all the sense in the world as well to continue developing GCC until such a time where the technical merits of LLVM are too great to ignore.

Unspoken is that there's not a ton of people ideologically devoted to RMSfree software these days. LLVM being usable by anyone is not sufficiently different for the current contributors and, I daresay, an overwhelming majority of folks who'd have a passing notion to work on such a project.

One could choose to learn to be an effective LLVM developer, taking what that community will give, and then just not contribute back to the community in much the same way as the GNU folks sneer about proprietary code, but I think the intersection between people who are interested enough in LLVM to work on it and the people so objectionable as to try such a scheme is small. (But I am an optimist.)

Why is it "not very nice" to GPL a fork of a BSD-licensed project?

If an author believes in their permissive license, they shouldn't complain about how their code is used.

Edit: fixed a typo.

Because the authors may intend to permit their code to be combined into some proprietary code base (which is to say that their idea of what constitutes permissiveness differs from yours).

The thrust of the question is why it's reasonable for them to not consider a GPL project either another instance of "some proprietary code base" or something better.

I think there are two answers.

One is potentially ratios of old code to new code.

But I think a bigger one is the threat to take "the community" with the code. Forks typically involve drama.

Isn't the intent of the BSD license specifically to refrain from dictating what licenses downstream users may add to their derived works? If you're okay with a downstream user making a fully "all rights reserved" proprietary product incorporating your code, I don't see how you could be against that same downstream user open-sourcing the resulting product under the GPL. In what sense would it be more free for them to keep it fully proprietary and not release it under the GPL?

I can see an argument that BSD-licensing any derived works so they can go back to the original project under the original license is the friendly thing to do. But then you would frown at both GPL and proprietary downstream licensees, since neither one is doing the friendly thing (in this definition of "friendly") and BSD-licensing their contributions.

While I agree with you, one could argue that developers of BSD works are ok with proprietary use but would rather not see an open source fork that divides the community. And the fork would not be available to them for further proprietary commercial use.

The authors intending to make proprietary derivatives is itself not very nice.

Relicensing code requires ownership of the code in question or some form of legal delegation. For example VLC relicensed something - I forget exactly what, maybe a core library - and the guy in charge had to track down every single person who contributed non-trivial amounts of code and obtain their permission to alter the license. To do what you propose would effectively require rewriting Clang from scratch, but even then it might be considered a derivative work and thus beholden to the original copyright holders in some way. (I'm not a lawyer so I'm a little hazy on the specifics.) Or at the very least, you'd have to write enough new or improved code that convinces people to use your fork of Clang, your part of which would be under GPL and so obligate distributors of your fork accordingly.

Licensing a derived work under a more restrictive license in a way that is compatible with the previous licenses does not require ownership of the code. My recollection has it that the VLC case was going from GPL to something permissive. Going from permissive (and "GPL compatible") to GPL is easier.

You could fork Clang/LLVM and integrate your own GPL licensed code, but the existing code would remain MIT/BSD and you cannot change that. Practically speaking it would boil down to whether you could separate what existed previously and what a court thought constituted a derived work.

The mind reels at the thought that anyone could have led such a charmed life that they would characterise this as "such hostility"

> why such hostility? why such trumpeting? why not respond on the mailing list?

I saw no hostility, and I'm not sure what you mean by "trumpeting"?

I don't know who the author is, but they felt like writing a blog post, and they did. People do that all the time.

Regarding the mailing list, typically one posts to a mailing list with a direct response to a previous message. If someone has a more general thought, that isn't a direct response to a concrete previous message, the mailing list might well not be the natural place to post it.

Overall the view being expressed in the blog is very reasonable, mainstream, and well-posed. It reflects reality - that LLVM is being used for all AST-export purposes these days. That's the world we live in now, for better or for worse.

>why such hostility

I really hope you didn't say that just because it appears the author is female, and I will give you the benefit of the doubt. The blogpost was not hostile at all.

Why did you feel the need to mention your suspicion of misogyny? Did the OP present any reason for you to believe he felt that way due to his comment?

Your comment sounds akin to the old political tactic of asking your political opponent if he stopped beating his wife.

I am not a man.

I don't think that's a very useful point, here. Stereotypes leave plenty of room for women wanting to cut each other down.

FWIW, I also read hostility in the original post, and don't expect that was influenced tremendously by the apparent gender of the author in my case or yours.

"If he doesn't want the GCC to be useful for non-free software, why ifs there language preventing compilation from falling under the linking clause of the GPL?"

I think one can sensibly draw a distinction between "I don't want to adapt the software in ways that will serve that purpose" and "I want men with guns to limit Freedom 0".

I don't think GCC is under any threat of being abandoned any time soon.

The intended audience of an open letter is rarely the addressee and I don't think this one is an exception to that rule. It merely uses the name of Richard Stallmann to widen the exposure (apparently successfully so).

If she wants to fork GCC she should go right ahead and we'll see if the dedication to maintain that fork over the next couple of decades is there or not. I don't think GCC has much to fear from such a development and possibly something good might come out of it if there is merit to her ideas or if the fork produces some other useful insight which can then be absorbed by the upstream.

Usually such forks lead nowhere, every now and then the fork will blossom and ends up overshadowing the original, that's the whole power of free software right there.

RMS is perfectly within his rights to decide the way he does (that's part and parcel of being a creative person rather than acting with some sense of entitlement about how others should modify their creation to suit your own intent) and bringing pressure to bear by attempting to gather a crowd that pushes for an issue is a low tactic.

> If she wants to fork GCC she should go right ahead

She doesn't want to fork gcc. She's saying that if people wanted to use gcc in this way so badly, they would fork. But nobody is interested in doing that, because it's easier to work with clang rather than try to fight with gcc. And the argument is that gcc is worse off for having driven those users away.

> She doesn't want to fork gcc.

Yes, I got that. I'm saying that she should if she feels the issue is that important (assuming she has the skills to pull off the fork).

> She's saying that if people wanted to use gcc in this way so badly, they would fork.

Conclusion: they don't.

> But nobody is interested in doing that, because it's easier to work with clang rather than try to fight with gcc.

That's most likely not a majority of the users but if clang serves their need that does not diminish GCC in any way other than that a couple of users moved to a different product. Big deal. GCC does not charge any price of admission, you are free to use it and you're free not to. If you're not driving the car you don't get to shout from the sidelines on what direction to take.

> And the argument is that gcc is worse off for having driven those users away.

GCC (and by extension Stallmann) are not driving anybody away. If you feel 'driven away' because someone does not act as you think they should then you have an entitlement problem.

I'm not sure you know the whole history of this piece.

This is ecologically a case of Stallmann driving people away. Over the last 10 years I have seen numerous patch sets to make GCC dump out usegiul ASTs, and they have been rejected by stallman for purely political reasons.

Stallman is perfectly within his rights to tell people he doesn't want this (in my opinion) very useful functionality in the FSF GCC, and to purposefully make it hard for people to maintain forks where they do as this functionality (which he has admitted to on multiple occasions), but he is certainly driving users and developers away.

Maybe I'm dense but I don't get the 'driving away' bit. Not doing something is the right of any creator. Stallman is the guy that first of all wrote the software and made it possible to fork. So if the functionality is really that much in demand get it over with and fork it so you can correct all these perceived slights and the world will be a better place for it.

But don't try to pressure the man into doing something he clearly does not want, whatever his reasons, that's akin to complaining the gift you got wasn't quite what you wanted.

I don't think anybody does care, they just like to argue with Stallman. Clang's parse trees are cleaner and more useful than GCC's ASTs. Even if this were implemented in GCC it would be limited and inferior, so why bother?

> I don't think GCC is under any threat of being abandoned any time soon.

Look harder. clang+llvm have a superior (because more modern) design with easy plugins and complete openness while the gcc toolchain carries with it the state of the art of the 90s. It was a remarkable product back then but in the 21st century, it's showing its age.

And I'm not even talking about the license aspects here, which also matter quite a bit (clang+LLVM have a license that is much more in line with real world needs than gcc does).

gcc is on a clear path to obscurity and obsolescence.

In my humble opinion most of the success of the open source movement comes from the economics of open source software, and not the licensing. Because unlike physical goods, software can be copied, and thereby given away and kept available to myself at the same time. That creates a situation where sharing software is almost always the better opion than not sharing it (cheaper, easier, faster, stronger etc).

If somebody creates a complex non business-critical piece of infrastructure, they have incentive to open source it. Because By doing so they can still use it as before, but get bug fixes and additional features for free from the community.

If I create an improvement for that open source code base, I also have an economical incentive to share that improvement back to the maintainers. Because I too can give it away while keeping it. If it gets merged, others maintain it for me, and all future updates to the software already contain my improvement. If I keep that improvement to myself, I have to patch all future versions of the software myself, which becomes harder over time as the software changes. Giving my patches back makes my life easier than not doing it.

I'm not against the idea of GPL, and the good intentions it has. It was necessary and good at the time. Some might still seem it necessary for philosophical or spiritual reasons, and that's okay. But most open source software that I'm aware of today, the majority of the open source revolution that the industry is experiencing right now (except for the honorable Linux) seems to be driven more by the economy of software sharing than the contractual requirement to do so.

This is totally amazing, I knew that RMS used to hold this opinion (hiding the GCC AST so nasty people can't misuse it), but I believed (wrongly it turns out), he'd abandoned it by now.

I can't see how he can defend crippling software, and blocking usecases which clearly a large set of users want (all kinds of editor intelligent colouring, competition), out of fear of a closed-source boogyman which doesn't exist any more, thanks to clang (if it ever did).

Because Stallman has never given a fig for the users, just the programmer-gods.

The point of copyleft is to protect users from being oppressed by programmers.

Copyleft is a collectivist ideology, it only ever cares about users as an anonymous mass, but not about individuals with individual needs and constraints.

Copyright is also a collectivist ideology. "To promote the Progress of Science and useful Arts" is even more anonymous than "users".

No user ever needs to be unable to arrange for maintenance of the software they rely on. That only benefits some developers by holding their customers captive.

The other reply says as much, but it bears repeating as what you said is so extremely incorrect. The GPL is and always has been a license that limits the rights of programmers in order to ensure the rights of users.

This is one of those, frankly, pretty rare cases where the users actually feel a limitation of the GPL (mostly because people that use Emacs has a significant overlap with programmers where the line between developer and end user is very blurry).

How many non-programmer users do you personally know that are capable of compiling a C program from source?

They could always hire other programmers to do that. And there's real value in having that option, or getting software from a community that works like that, most famously the Linux distro scene.

Not many people are capable of fixing their car personally, but they do benefit from not being required to go to Toyota whenever it breaks. Nonfree software is like an appliance which you're legally forbidden from modifying without permission from the original maker.

Missed your reply.

Actually it is pretty irrelevant how many non-programmers are capable of compiling or meaningfully editing the C program. The point is that a programmer cannot (reasonably) edit to restrict you freedom.

However, after rethinking what I wrote, I should clarify that while the underlying principles are the same regarding what RMS is trying to do here (limit programmers to protect users), the GPL has nothing really to with this particular fiasco.

> the rights of programmers

So adding proprietary license on top of software which one has not authored is a right that belongs to programmers?

Yes, because non-copyleft Free licenses precisely grant this right. By contributing to that project (and licensing those changes under that license) you are saying that this is allowed.

To be honest, I think it was useful back in the 1990s.

> …out of fear of a closed-source boogyman which doesn't exist any more… (if it ever did).

It most certainly did. Read here[1] about the history of Objective-C. NeXT tried to keep as much of it as possible proprietary.

Sadly, because LLVM is so good but doesn't have copyleft protection, we live in a world where something new and interesting like Swift may never be non-proprietary.

[1] https://en.wikipedia.org/wiki/Objective-C#Popularization_thr...

> we live in a world where something new and interesting like Swift may never be non-proprietary.

Should Apple not have a right to make their own proprietary language?

Let's not forget that Apple is a big part of why LLVM is as well known as it is.

Proprietary language? You mean like a single platform language? What a complete waste that would be.

Languages can't be proprietary, anybody can re-implement some language if there is a spec. Whether you can name it the same or not is another issue but non-proprietary languages usually don't survive for very long so it would be in Apples own interest that swift ends up in as many hands as possible.

Oracle still doesn't understand this completely about Java, maybe Apple will never understand it about Swift, meanwhile all those non-proprietary languages will flourish.

> ... proprietary languages usually don't survive for very long so it would be in Apples own interest that swift ends up in as many hands as possible.

This is wrong thinking and it misunderstands Apple's goals and motives for Swift.

First and foremost, it's a replacement for Objective-C, which is itself effectively proprietary - there are open source compilers and some legacy openstep implementations, but the driving force behind the language has been exclusively Apple for at least a decade now. In that context, Swift has the same expected level of success as Objective-C, owing to the community that exists around its predecessor. And, for Apple, the important metrics for success with Swift are entirely focused around the effectiveness of the language in support their platform. Given the relative popularity of the platform, they can reasonably expect that people will use the language to gain access to Apple's userbase, because it's a valuable commodity.

Second, Apple doesn't care if Swift has a long life, at least, not per se. They want it to be used and to be successful because it's where they're probably moving their platform in the medium to long term. But they're not invested in the longevity of the language so much as they're invested in their platform. If, in another decade, they decide that Swift has outlived its usefulness, they'll replace it and let it die. Any other scenario for the language failing entails Apple faltering as a company, in which case, they don't really care about the Swift's success.

(I snipped a "non-" off proprietary, because it didn't seem like what you were arguing from the rest of the post.)

Apple of course has the right to do whatever they please, but the world would be better if their neat new language was available in other contexts than just their system. It pretty much guarantees that the only people who will use it will be a certain class of iOS developer. I will probably never use it unless I am forced to for a job or something.

Swift is currently in the same position that C# was in before Mono. It will probably be popular in certain circles, but it's not going to ever dominate the language field like Java, Javascript, and C do. Microsoft's recent freeing of the .NET infrastructure makes it a real, bona fied choice now. Apple should follow suit early, for the good of the language.

Objective-c, despite having compilers on other platforms, 99% of the time is used for programs running on an apple platform. It just hasn't made it into other universes, despite itself having many nice qualities (especially over c++ imho). Swift is Apple upgrading their own environment, which as an iOS dev is welcome.

I'm not sure the cross-platform framework problem is one that helps them or makes much money compared to what is status quo. But at least their proprietary world got better for those of us who write for it.

In the world RMS wants, Apple would not have the right to develop Swift and make it proprietary. That's pretty incredible to me, and far more relevant than discussing Swift's barriers to adoption.

In RMS's world, hackers close ranks to make sure the power stays in the hands of the people, not the corporations. Sure, corporations might develop a bit of proprietary code now and then, but they are outpaced by armies of hackers writing GPLed code and replicating any innovations they develop. All the best compiler toolchains are GPLed in this world, and corporations are basically forced to participate in the Free Software movement, or suckle at its teat. It would not be possible in practice to sell software, because any software your computer could run would have to be GPLed!

A lot of other stuff happened instead. Now we have hackers working at corporations writing open-source code and sharing it with other corporations and the world. Companies don't sell software so much as provide various human and computer services. Corporations aren't evil, they can provide funding and organizational structure that is actually pretty valuable. And so on.

>In the world RMS wants, Apple would not have the right to develop Swift and make it proprietary.

In the world RMS wants, people would shun proprietary software due to it not giving them the rights which are afforded to them through copyleft.

This is what he is advocating, that people should not accept proprietary software due to it not respecting their rights, not that proprietary software should be illegal.

aside from obfuscated or secret source, proprietary software relies on legal restrictions. RMS would be perfectly fine removing the artificial legal restrictions that proprietary terms use if it didn't hurt the ability to protect software freedom for free software.

Proprietary software terms should be illegal.

What you're saying is misleading. Here's how I would say it:

"In the world RMS wants, Apple would not have the right to develop Swift on top of a GPL-ed compiler platform and make it proprietary."

That's not incredible at all, and makes perfect sense.

I've never seen the the Free Software movement as "hackers" against "corporations". Places like Cygnus (bought by Red Hat) made a mint selling Free Software consulting services. Nobody ever had a problem with that. They thrived because they were good and they solved real problems for people. None of that is antithetical to either the Free Software movement or corporations.

> In the world RMS wants, Apple would not have the right to develop Swift and make it proprietary.

I am glad that you are more clear about this position of his than he is himself. Personally, I would never have guessed it.

The utopia he desired circa ... 1988 or so was one where all programmers were paid to do their thing by the government, and all software was his type of free.

Great, we programmers can quit our jobs and compete for a small number of government grants like the academics! :)

Well, it was implied that everyone would be eligible for these grants, but, yeah, in reality, only a few would be allowed to program, and one reason RMS probably didn't think about it is that he's a good enough programmer that he'd qualify.

Except, of course, the process would be very political, and he doesn't play that game at all well.

"The FSF campaigns for free software adoption and against proprietary software." - fsf.org/about

The FSF position is and always has been that the distribution of non-free/proprietary software works against the "freedom of computer users". That last word is important, because the FSF concerns itself with the rights of end users, not programmers or software companies. That's the big philosophical divide between "free software" and "open source": the 'free' side makes an ethical/consumer protection argument concerning end users, while the 'open' side makes a pragmatic argument mostly concerning developers (cathedral vs. bazaar, etc.).

Yes, but quote me the part where they are against the right to produce proprietary software.

If by that you mean advocating the banning of proprietary software, I don't know that they've done so. They do advocate that governments exclusively use and promote free software[1]. Some of their publications also refer to their "goal of ending the injustice of nonfree software", and that distributing proprietary software is "unethical" and "mistreats" users[2].

EDIT: My interpretation of Stallman's politics is that he would happily support legislation to forbid nonfree software, but I think the FSF intentionally avoids the subject for the sake of their libertarian supporters.

[1]: https://gnu.org/philosophy/government-free-software.html [2]: https://gnu.org/philosophy/free-software-even-more-important...

Indeed, RMS circa the early-mid '80s---like, when we were roommates precisely when he started the GNU project in September 1983---would have been entirely happy to have proprietary software banned. I doubt his position has changed since then. He was a big fan of Hugo Chávez....

He was also, a while after the start (like 1985), very harsh with "Software Hoarders" like myself who then worked on non-copyleft software.

> A lot of other stuff happened instead

But before that happened something else happened (which is more important, and you forgot about it, it seems) and that is GCC, Linux and other free software. Linux runs on tiniest embedded devices, Android phones, military hardware, servers, and so on. It was possible in large by GCC and GNU.

Have you been around in the early 90s and 80s. Having high grade OSes or compilers that were free as in beer or speech would have sounded ridiculous. You'd sound like you were from Mars if you talked about such things.

Yet here we are. We have reliable, high grade operating systems based on ideas of fruits of free software movement -- CentOS, Ubuntu, Deb etc. Because of GPL in large anyone can take advantage and reap the benefits of shared work (such as by using CentOS instead of RHEL) while letting Redhat employees still put bread on the table.

Show me Apple's OS X code that was modified for NetBSD and FreeBSD projects? Where are those improvements? I haven't seen them.

So yes now this "service" and "cloud" stuff is happening. But let not forget that for this to happen the even the idea of "open source" and "free software" as viable alternative had to take root. I believe if it were not for GPL and Stallman we wouldn't have had this culture of sharing between large corportations.

> Should Apple not have a right to make their own proprietary language?

Should Apple's users not have the right to use, share, study, improve, extend and share improvements and extensions to the languages and tools they use?

Or, in answer to your question: no.

>out of fear of a closed-source boogyman which doesn't exist any more, thanks to clang (if it ever did).

Eh, what ? Apple is already shipping their proprietary fork of Clang which supports their proprietary language Swift, this is exactly what Free Software which Stallman advocates is working against.

The whole idea of Free Software is that the end user will have the full rights to examine, modify, copy, run said software, proprietary plugins in GCC flies right in the face of that, so obviously Stallman is opposed to them.

>Eh, what ? Apple is already shipping their proprietary fork of Clang which supports their proprietary language Swift, this is exactly what Free Software which Stallman advocates is working against.

Thats exactly the point. Anybody wanting to make a proprietary language implementation, or proprietary IDE is already using llvm anyway, and would remain doing so. New projects of that nature would almost certainly still use llvm. The only people really being affected by this are people who want to use GNU tooling, but are left with deliberately crippled tools.

The ability to develop plugins for GCC has existed for years now, but nobody has used it to do the evil things RMS insisted would happen (remember, he blocked the creation of the plugin interface for many years). The main reason is that Clang/LLVM is just much easier and nicer to work with (e.g. you don't have to write and maintain your own plugin to export an AST instead of having it be part of the core project). Hence all the brightest young minds in compiler research and language development are using LLVM in their work instead of GCC and an entire generation that could have been using and contributing to GNU software are working to improve 'the enemy'.

Its hard to think of a more valuable group of people to drive away. Or a more thorough way to drive them away than to try to put intellectual shackles on them. Stallman's suggestion of only exporting a gimped AST that only allows a few specific transformations gives people involved in languages and tooling the same reaction as RMS feels when told he can't see the code for the software on his printer.

>The whole idea of Free Software is that the end user will have the full rights to examine, modify, copy, run said software, proprietary plugins in GCC flies right in the face of that, so obviously Stallman is opposed to them.

Nobody is proposing creating proprietary plugins for GCC. People are proposing a GPL licensed plugin to export the AST for use by emacs. No proprietary code involved at all. RMS has said he would block the use of such a plugin in emacs, thus deliberately crippling emacs, which is why emacs is probably going to get forked (again).

Whether you find it likely or unlikely to happen is not part of the equation, copyleft was created to _ensure_ as far as possible that the end user would have certain rights.

>The ability to develop plugins for GCC has existed for years now, but nobody has used it to do the evil things RMS insisted would happen (remember, he blocked the creation of the plugin interface for many years).

First off the plugin api is unstable which discourages out-of-tree patches, secondly there's the gcc runtime library exception which only allows distribution of proprietary binaries created with gcc if said binaries was not generated using proprietary plugin(s).

>Nobody is proposing creating proprietary plugins for GCC. People are proposing a GPL licensed plugin to export the AST for use by emacs.

But allowing for that will also make it possible to use a proprietary backend with GCC, thus allowing the circumventing of rights which copyleft licensed software is there to ensure. It doesn't matter if you think it's 'unlikely to happen', again copyleft exists to ensure that this does not happen.

There's a difference between creating something and then also promoting it. The FSF and the GNU project shouldn't encourage the creation of the plugin and they shouldn't promote it. However, they cannot stop anyone writing the plugin that exposes the AST in such a way to be usable by proprietary programs. The Emacs project also shouldn't promote this project.

This is exactly similar to how FSF and GNU don't promote the Windows version of Emacs. They don't hinder it or stop it, but they don't promote it or mention it either.

I think the Emacs maintainer blew things out of proportion and so has everyone else.

> However, they cannot stop anyone writing the plugin that exposes the AST in such a way to be usable by proprietary programs.

I'm not entire sure they couldn't... It really comes down to the definition of a derivative work. It's often assumed that a process boundary would somehow raise some legally impenetrable wall between works, but I'm not sure a court would necessarily agree.

RMS would very likely respond to this by frequently changing the plugin interface and updating only the blessed plugins. Linux is not entirely dissimilar in how it does device drivers.

It feels like the influence of (L)GPL and perhaps even Stallman is almost at a close. These days I'm genuinely surprised if I see something new released under an (L)GPL license. And when it does happen it's often released under a more free MIT or BSD license soon thereafter.

I think the GPL is still useful.

It absolutely is. That doesn't change anything in my comment though.

Yes, the grandparent is crazy to think the GPL isn't relevant. In certain circles it isn't as popular, the GP must travel in those circles.

It's still wonderful to be on a linux system where I can just "apt-get source <pckage>" and look at how it works, try to work around bugs, etc. The attitude that you should be able to break apart anything you're running and hack on it is the fundamental principal of the GPL.

I have a suspicion that people who dismiss the GPL nowadays are young enough to have never lived through the times where the standard unix server was running SunOS and good luck to you if you ever found a bug in the system. You know, the days where you had to pay for a (sucky) compiler.

I think a lot of people are shortsighted and they sort of see the world immediately in front of their eyes. I am building a product, I need a library, GPL, fuck GPL! Gah, gotta search for a BSD one and curse GPL in the process.

They probably never lived in the days before Linux, GCC and free software as something that can happen in reality. Yet looking back here we are. People sharing code on github, companies sharing their code (either licensed as GPL or other open source licenses). High grade languages, compilers, OSes, kernels, crypto libraries all free and/or open.

I think that would not have happened had it not beed for Stallman and GPL.

A lot of developers I find are also bored or ignorant to study or understand licensing. Concepts like "copyright", "license", "open", "free" are all confused and relegated to mumbo-jumbo legalese. Today most have internalized the simple heuristic "GPL" = stay the fuck back or our legal department will slap me on the head, "BSD" = good, use anyway you like.

I would say that is mostly because, thanks to RMS and the GPL, we now live mostly in an ecosystem where the threat of a world dominated by closed, proprietary software has been pushed to the background.

People don't feel a strong need to "weaponize" their licenses against a dormant enemy. Hell, there's a whole generation of hackers for whom the threat is merely theoretical, a bit of historical hacker folklore. For them, copyleft clauses are merely a nuisance that serves no immediate practical purpose.

However, should one or more major players be stupid enough start abusing this and stop playing nice with the open source community, my guess is you'll suddenly see an upsurge of GPL licensed projects.

MIT and BSD licensed projects are cool as long as everyone plays nice, and most companies, even Microsoft, have learned to play nice. That may not always remain the case.

> I would say that is mostly because, thanks to RMS and the GPL, we now live mostly in an ecosystem where the threat of a world dominated by closed, proprietary software has been pushed to the background.

I think that threat is alive and well, especially in mobile and sooner or later everything will be mobile except for server side.

Some battles were won but that war may still very well be lost.

The way I see it is that the GPL is inconvenient as long as not everyone is using it. I'd love to live in a world where everything was GPL, but as long as something is not GPL, it's very difficult to work with anything other than BSD / MIT / Apache-style licenses. I work in an almost entirely open-source ecosystem, and find that most customers want free-as-in-freedom software, but (especially in some industries) they're terrified of the GPL because they don't want to restrict their options in the future if they need to use software that isn't "free" but is required for them to be successful.

but (especially in some industries) they're terrified of the GPL because they don't want to restrict their options in the future if they need to use software that isn't "free" but is required for them to be successful.

I would love to hear a succinct response to this concern, which I've encountered numerous times when I've sought to use a GPL library or solution and the boss/manager goes pale at the thought of GPL. What is so terrible about it?

- Are there libraries/solutions you cannot use simply b/c you have a GPL piece in your toolbox?

- "derivative works" as I understand this is only if you modify the source code itself. Does stuff built on-top-of or next-to the GPL'd code have to be GPL too?

Because copyleft is intentionally viral. Controlling that virality is hard. It's easy for your non-GPL code to become infected. The license is very long and there is not consensus on how it applies. It's largely untested in courts. Stallman believes that even dynamically linking GPL code constitutes a derived work.

> Does stuff built on-top-of or next-to the GPL'd code have to be GPL too?

"derivative works" is often the simple question on what a non-technical judge would deem as a single product. If you have to explain and label "parts", counting it as a derivative works is the safer bet.

I dunno. I used to feel this way, even feeling that the GPL had outlived its usefulness, but I have had a change of heart in the last decade or so. I think the GPL might be the only hope for long-lived software that serves the interests of its users.

I hope that programmers who sneer at the impracticality of the GPL and RMS's zealousness can take another pass at appreciating it, when you think about what its implications might be for a project thirty years in the future.

Thanks, I could not agree with you more. Last year I released something under the GPL, and when a few potential users complained I wimped out and switched licenses. I think that I made a mistake doing that. I am working on something else interesting and I plan on sticking with the GPL, even though my project is for Pharo Smalltalk and I think GPL use for Smalltalk projects is rare.

I think that in the distant future we will see very old, very well tested software that changes only slowly. I would like to see that software using GPL or AGPL.

> Last year I released something under the GPL, and when a few potential users complained I wimped out and switched licenses. I think that I made a mistake doing that.

If it's your own code, you can change licenses back (say, for the next version) if you want to.

Only if you wrote 100% of it or got other contributors to sign over their copyrights. (right?)

"it's your own code" is a special case of this.

If their contributions were licensed to him suitable for inclusion in a project released under a permissive (and GPL compatible, but most are) license, then he could relicense his code and thereby effectively relicense the project. People could, in principle, isolate the BSD (or whatnot) portions and use them in other projects, but that's probably only relevant if it's a significant portion of the code.

Thanks for the suggestion, that is exactly what I did.

If the GPL is at a close it is because enough critical infrastructure is, for historical reasons, based on BSD.

I think GPL is more important today than it ever has been. Core infra software should all be GPLv3.

GPL is one of the most clearly logical apolitical instruments of change that has ever existed.

I don't see any change in the licensing landscape at all, permissive licensing remains king for libraries, frameworks, while copyleft remains king for 'full end product' style projects.

Some people seem to take the upswing of web oriented frameworks as a sign of permissive licensing being favored across the entire OSS ecosystem, but it's simply in an area where permissive licensing was already entrenched (again frameworks, libraries) that has seen a lot of recent developer activity.

Something interesting has been happening in the Open Source world. In the beginning, open source software was developed mostly by academics and free software advocates. Copyleft licenses like the GPL became very popular as a means to prevent for-profit companies from using all this free software without giving back. There seemed to be a struggle between closed source proprietary software, and free open source software on the other side.

The lines have blurred, and now a lot of open source projects are developed and maintained by for-profit companies. Projects like clang, SQLite or PostgreSQL are all developed mostly by profit-oriented companies. These projects use liberal licenses; they aren't interested in "protecting" their code -- for these projects, the situation is actually reversed. Proprietary software vendors make large parts of code freely available to the world!

Maybe this is a result of the GPL; evil corporations are afraid of the GPL and therefore they support projects with liberal licenses.

But maybe the GPL is just not necessary anymore; companies see the inherent advantages of open source and make (some) code available even without the GPL gun pointed at their head.

What a wonderful world this would be! The GPL always seemed like fighting fire with fire. Maybe the world is better than we thought.

> The GPL always seemed like fighting fire with fire.

That's exactly what it is. You have to really appreciate the care that went into drafting that, if there ever was a real-world hack the GPL would be it.

There are a fair number of interesting PostgreSQL forks that are completely proprietary. Those guys DO care about their source code. That's the exact case GPL is designed to protect against, there are developers that contributes to PostgreSQL and cannot use that code.

There does seem to be an overall shift and source code isn't seen as it once was but there is no shortage of companies that would gladly keep "their secret sauce" secret. How many web services use tons of opensource and short of reading their obfuscated javascript from their web pages, do they make the source available? And realistically, it's data and the service that is their edge. Take github for example.

RMS comes across as a bit extreme at times but we are where we are in part because of him.

In the new world, no one cares that there are proprietary forks of Postgres. Proprietary software and free/open source software can coexist peacefully in our new world.

For example, the PostgreSQL project isn't harmed by CitusDB making a proprietary extension. Citus even decided to open source part of their extension, resulting in a net win for the PostgreSQL community. If PostgreSQL was GPL, Citus probably wouldn't contribute anything.

Or take EnterpriseDB, probably the largest fork of PostgreSQL. Yes, they have a proprietary product that they sell to enterprise customers. But just a quick look at the Postgres hackers mailing list shows that the developers at EnterpriseDB make significant contributions to the PostgreSQL project, even though a part of their work is closed source.

And I'm in a similar position: I make a living from selling a closed source client I developed for Postgres. But I also maintain Postgres.app, a completely open source server GUI for running PostgreSQL on OS X. If I couldn't sell licenses for my closed source app, I couldn't work on the open source project. (People just don't pay for open source software unless they need support. If your goal is to make software that doesn't need support, you're fucked.).

I understand that Stallman objects to proprietary software in principle. If you follow that school of thought, then the GPL is the way to go. But if you don't care about proprietary software -- as long as enough open source software is available -- then the new world has a lot of liberal licenses to choose from. In this new world, open source hackers and for-profit enterprises work together, instead of fighting another.

You use terms in a different way than I. The "Open Source world" started in late 1998. The free software world started in 1983, and some free software developers do not identify as being part of the open source world. Hence the most accurate term, though clumsy, is "free and open source software" or "FOSS". The history of the CeCILL license shows that it's possible for something to be free software according to the FSF but not regarded by the OSI as open source. (CeCILL 2.1 is both free and open; I refer to earlier versions.)

Nor does free software have any requirement to "give back". A for-profit company can internally use as much free software as it wants. It's only when the free software is distributed outside of the company where the licensing clause come into force, and it only applies to the recipient. I think this is more correctly stated as "give forward".

Nope, open source as in for example X goes back no later than the mid-80s. It very specifically defeated the technically superior Sun NeWS (https://en.wikipedia.org/wiki/NeWS) due to the "MIT License" it used vs. Sun's demand of ~$100K to play their game. And that was a primary driver in James Gosling and company requiring Sun to liberally licence Java, his next project. (And Gosling, BTW, created the EMACS that Gnu EMACS is a fork of.)

In another thread I criticized Dr. Stallman's responses. I stand by the criticism. _However_, he hasn't actually decided yet, he's just pursuing the matter outside the mailing list.

Could we let him either change his mind or reaffirm his initial conclusion as final before we heap extrapolations on to the pile?

Should Emacs get complex refactoring and code completion? Yes. Should it get them by way of GCC? Ideally. Will it harm Emacs and GCC if this functionality remains crippled in both components of the tool chain? It seems likely. Has RMS decided to go this way? Not yet.

BTW: The latest in the thread is a proposition which RMS actually asked for in his initial response: https://lists.gnu.org/archive/html/emacs-devel/2015-01/msg00...

Shouldn't it be "A free letter to RMS" =)

I have a feeling Dr. Stallman remembers EGCS, xemacs and much more. What's the old BSD saying "Shut up and hack!" ... amusing s/eliza/M-x doctor/ may also remember the tcl wars also.

I really don't think this is an argument that will convince Stallman. As stated, there have been forks of GCC (as well as Emacs) before. It's not as terrible a threat as it might seem.

egcs was big enough of a threat that it became the official gcc codebase.

egcs was free software working exactly as it should, you don't like the current direction, fork it, and thanks to it being copyleft the fork is entirely open and can later be merged back or as in this case, become the new official project.

This argument is based on the assumption that LLVM is equivalent to GCC. If that were true, it wouldn't have really mattered that GCC exists or what it does and the argument wouldn't have been made in the first place. The fact that this argument exists undermines itself.

They're not equal from the viewpoint of the FSF, and since this is an issue about FSF Gnu EMACS using such output from the FSF GCC, that mostly political detail is highly relevant.

Reply on news.ycombinator.com