
An open letter to Richard M. Stallman - DiabloD3
http://elizabeths-blargh.blogspot.com/2015/01/an-open-letter-to-richard-m-stallman.html
======
dmm
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.

~~~
vor_
> 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?

~~~
Perdition
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.

~~~
dragonwriter
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.

~~~
bilog
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.

------
nly
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.

~~~
bilog
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.

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

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.

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

------
tatterdemalion
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?

~~~
ForHackernews
> 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.

~~~
profquail
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).

~~~
zanny
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.

~~~
eropple
_> 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.)

------
jacquesm
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.

~~~
Gracana
> 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.

~~~
jacquesm
> 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.

~~~
CJefferson
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.

~~~
jacquesm
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.

~~~
alextgordon
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?

------
kevingoslar
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.

------
CJefferson
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).

~~~
TylerE
Because Stallman has never given a fig for the _users_ , just the programmer-
gods.

~~~
smithzvk
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).

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

~~~
djur
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.

------
omouse
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.

~~~
hga
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.

------
forrestthewoods
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.

~~~
santacluster
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.

~~~
TallGuyShort
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.

~~~
spopejoy
_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?

~~~
forrestthewoods
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.

------
jakobegger
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.

~~~
Nelson69
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.

~~~
jakobegger
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.

------
slowmovintarget
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...](https://lists.gnu.org/archive/html/emacs-
devel/2015-01/msg00223.html)

------
UNIXgod
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.

------
krig
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.

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

~~~
gillianseed
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.

------
mehrdada
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.

~~~
hga
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.

