
Stallman on GCC, LLVM, and copyleft - microtherion
http://lwn.net/Articles/582242/
======
saurik
When this came up yesterday[1] I made a comment that a lot of people seemed to
find interesting (by votes, not responses: there's nothing in it really to
respond to), so I figure I'll make it again today.

[1]:
[https://news.ycombinator.com/item?id=7116144](https://news.ycombinator.com/item?id=7116144)

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

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

~~~
thatthatis
With copy middle there are always going to be examples of "x wasn't re
released into the community." I think focusing on these is extremely short
sighted. It cedes a premise that the way to judge the health of an open source
paradigm is %_advances_open_sourced, or as a negative indicator
#_advances_not_open_sourced.

The true equation for the value of an open source paradigm should be:
#_advances_open_sourced, and nothing else.

It doesnt matter if 99% of advances stay closed, what matters is if there is
enough value repatriated.

Copy middle allows a company to take something open source, invest speculative
resources on improving it, and it successfull sell for a portion of the
incremental value - both improving the quality and decreasing the cost of
software to consumers. Then, if/when a company tries this and fails to find a
market, the advances sometimes/often get repatriated as part of the shutdown.

Copy left tries to use anti-ownership ideals to ensure software remains free.
This seems like a good idea, until you realize that copy middle effectively
harnesses capitalist motives to make free software better.

In my mind: Copy left is, by design, a virus. Copy middle is a symbiotic guest
organism. I know when given the choice between a probiotic and the flu virus
which I want to ingest into my body. I have the exact same preferences when it
comes to what I invest in my company.

~~~
saurik
This is your opinion. I will not even attempt to say it is not a valid
opinion: a lot of people I know hold this opinion, and at least in the short
term it seems to be a consistent opinion. I think there is an interesting
discussion to be had "in the long term", but it is just that: a discussion.
However, I am going to assert that it is, in fact, an opinion. The thing you
need to understand is that the other side of this particular opinion does not
actually care about _either_ "#_advances_open_sourced" _or_
"%_advances_open_sourced": the goal is freedom, not openness, and these are
assets that are neither equivalent nor convertible.

To put this into a very simple example: if Apple open sourced every single
software component on the iPhone, that would be extremely "open". We would
know everything about how the iPhone worked, and we'd have learned a lot as a
community about how to build mobile phone operating systems. This would help
other people and companies work on mobile phones, and might have positive
effects on things entirely unrelated to mobile phones. To the people who care
about variables related to "#_advances_open_sourced", this would be a great
outcome, and "%_advances_open_sourced" is even 100%: seems great.

But, in such a universe, I will argue that the users of an iPhone are still
not "free" because they are unable to take the software running on their
iPhone and replace it with modified software based on all of that wonderful
open source code. In fact, lest you say "people then shouldn't buy an iPhone",
it might be the case that users of _any device_ are not free, because there is
absolutely no guarantee in such a universe that any of the numerous devices
that are based on this open source software--even if 100% of the software on
these devices is itself open source--actually allow users to modify the
software running on them (hence, GPL3).

This is the difference between "free" and "open", and in my understanding this
is why Stallman makes the points he makes: he doesn't care whether there are
more cool and fun toys built out of open components, what he cares about is
whether the toys we have restrict our freedom. It might be that a world where
we are more free has fewer toys. In my interpretation, Stallman would consider
that a "win" for mankind. In his mind, that argument "so don't buy an iPhone"
seems to be related to the argument "so don't link against their code", and he
wants people to stop: the idea is that if you don't like people restricting
freedom, you should actively avoid yourself supporting it.

(So, that's all I really have to say in response. However, if you--or anyone
else--finds this kind of stuff interesting, I spent a lot of time a few months
ago writing a lot about this subject, and in particular this tradeoff, in a
comment thread on Hacker News when FreeBSD deprecated gcc. Of particular
highlight, I go into detail on the property that GPL is more a license about
binaries and hackability as it applies to end users than about source code and
extensibility as it applies to developers, as well as why this causes debates
about this subject among a bunch of developers to be problematic, due to the
different incentives developers have from end users.)

[https://news.ycombinator.com/item?id=6209724](https://news.ycombinator.com/item?id=6209724)

~~~
thatthatis
My biggest issue with gpl/copy left is that it is a _kind_ of freedom obtained
by forgoing other freedoms. It isn't a more _free_ platform, it is a more
_open_ platform.

If I work on a gpl product I give up important characteristics of ownership in
that work. I lose certain freedoms to gain others.

I define freedom as the ability to do as I wish. The gpl restricts that, and
thus can't be said to be totally free.

The gpl is an interesting and in many ways compelling philosophy, but it ties
you to its philosophy - it doesn't allow you the freedom to follow your own.

\---

You mention long term value. I think that, like the medicine patent system,
copy middle gives us higher long term ecosystem value at the expense of short
term value. I should put my assumptions into an economic simulation some time
and really model out the question of in which circumstance copy middle vs copy
left gives higher long term value.

~~~
saurik
All freedoms are inherently subjective: freedom from slavery is a restriction
on owning other people. This is why this discussion is so hard: the people who
have to choose a license are the people who have to give up freedoms for
others to be more free. One argument is that the second groups of people (end
users) happens to superset the first group of people (developers) and is
fundamentally larger. To maximize freedom thereby would have the developers
"take the hit" (although again: developers are users, too). This is, in fact,
precisely what I spent so much time a few months ago discussing: I encourage
you to read what I wrote then, such that I need not repeat myself endlessly
here. To be very clear: I directly address your entire concern about relative
and subjective freedom in that precious discussion.

[https://news.ycombinator.com/item?id=6209724](https://news.ycombinator.com/item?id=6209724)

As for your comments on the short vs. long term issues related to
"#_advances_open_sourced", I think that is an interesting discussion to have
at another time, as it is off-topic today: Stallman, as I have argued, does
not care about attempts to maximize "value" in the way you have defined it,
whether in the short or long term; instead, he has defined "value" as
"freedom", and I imagine (or at least hope) that a future where mankind is
living without all the fancy toys we have, _but where the things we have we
actually own ourselves, with nothing between us and modifying those things in
the way we please_ would be a "win". All attempts to maximize the thing you
care about are, to him, probably nothing more than a distraction. Again:
that's not to discredit the things you care about; it is only to say that the
goals themselves are mere opinions that people have, and that to understand
others requires thinking in their terms.

~~~
thatthatis
I think you've fairly accurately portrayed Stalman and the FSF. But, I don't
care very much if Stalman wants x or y in the world. I'm less concerned with
debating his intent in a literature review way than I am with choosing the
licenses that lead to the best outcome for humanity in the future. The
question shouldn't be what he wants, except to the extent that it inform the
larger question of "what is good for society." So I don't see why you would
think that my rubrik for what is best for society is off topic here.

"I have a right to own slaves" is a bad analogy, it doesn't mirror the kinds
of trade offs we're discussing here. Slavery is not a case of balancing rights
between two people, it is a case of one person's supposed right negating all
rights in the other person. It's not very dissimilar from "I have the right to
kill."

~~~
saurik
> So I don't see why you would think that my rubrik for what is best for
> society is off topic here.

It is off-topic because it assumes that other people share your rubric. It is
off-topic because it ignores the real question, which is whether that rubric
is even the correct rubric to have. It is off-topic because it has nothing to
do with whether Stallman should have said the things that he did. Let's say
that someone else showed up, and said "we should be trying to optimize for
money in Apple's bank account; instead of GPL, which seems extreme, we can
strike a better balance that provides more money into Apple's bank account".
Do any of us here care about the amount of money in Apple's bank account?

My contention is that caring about how much software in the world is open
source, or how much software in the world exists, or what powers mankind has
given access to that software, is an interesting and potentially valid rubric;
and, it seems to be at least a major component of your rubric. Sadly, this
means you are thereby doomed to spend forever arguing over how to best make
tradeoffs to help you optimize for that rubric when dealing with people like
Stallman. You will bring up that rubric, and they will seem incompetent to
you, because they _just don 't get it_: "they are _throwing away so much
value_ ".

And they, in turn, will look at you as naive, because you are attempting to
optimize for something _they don 't care about_ and would be perfectly happy
to _throw away entirely_. Trying to argue whether, in the long term, BSD or
GPL (for example; feel free to insert any decision that must be made instead)
is good or bad for that specific rubric is entirely irrelevant to them,
because even if BSD was _amazing_ for that rubric, and even if GPL was
_miserable_ for it, at the end of the discussion the GPL advocate will say
"well, that was an interesting waste of time: now where were we on trying to
get everyone to use GPL?". You won't succeed in convincing them of anything:
you are just wasting time.

Now, maybe, on the other side, I'd make some inroads with you by trying to
argue that, in the long term, making things "too free for developers" actually
comes around to "bite you in the ass" and that you end up in situations where,
for example, all major mobile browsers are now effectively closed source in a
world where everything is increasingly moving to mobile-only platforms, and
that by having invested so strongly in WebCore (LGPL) instead of Gecko (GPL)
we caused that reality by allowing WebKit (BSD) to exist... but this is going
to be a really long and really painful argument that has nothing to do with
Stallman hating on gcc, and it is not one I feel like I should have to spend
my time today arguing. I honestly don't even think these arguments really get
anywhere, and tend to just make everyone angry.

> "I have a right to own slaves" is a bad analogy, it doesn't mirror the kinds
> of trade offs we're discussing here. Slavery is not a case of balancing
> rights between two people, it is a case of one person's supposed right
> negating all rights in the other person. It's not very dissimilar from "I
> have the right to kill."

 _sigh_ As you seem to only be quoting the things I am saying in these
immediate comment threads, without taking into account the expanded context
I've now linked you to twice, I am going to have to consider this conversation
a waste of time :/. The extent to which that exact analogy matters in the full
argument I asked you to read is clearly "not much" (it was there, and is here,
just an example of freedoms being relative; in the full argument I went into
extreme detail on exactly how the freedoms here are subject), and yet you seem
to only be responding to the teaser summary I laid out in this comment. I
should not have to repeat that entire thread here: all I asked you to do was
to read that discussion and come back, and I do not understand why that is so
hard for you to do :(.

~~~
thatthatis
You seem unnaturally concerned with me understanding what Stalman is saying
for how little you seem to be trying to understand what I am saying.

Im declining to continue as well, if you're going to throw around text walls
full of straw men I see no value in continuing this conversation. Further the
idea yield per word is very low in what you've writen here, so no I'm not
going to go read your dissertations elsewhere.

Your strawmen so far in this thread: "right to own slaves" "value apple's cash
balance as a social good"

Stalmans statement was about the good of gpl vs bsd, alternate rubrics are
absolutely on topic.

------
codeflo
I'm still quite convinced by the idea of software freedom, as explained in
Stallman's earlier writings: [https://www.gnu.org/philosophy/free-
sw.html](https://www.gnu.org/philosophy/free-sw.html)

Having said that, I find Stallman's war rhetoric increasingly disturbing:

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

This is the language of war propaganda, and shouldn't have any place in
rational discussions.

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

All while endorsing the Affero GPL, a license that doesn't even allow users
full control over their own servers.

Maybe if someone is that convinced of a cause, the ends seem to justify every
means. I'm not sure what's going on at the FSF, but it seems that they've lost
sight of some of their original principles.

~~~
mjn
I don't think it's much of a departure from original principles. The original
impetus for the FSF was the "closing off" of some previously public code by
MIT AI-lab spinoffs, who hired away developers and withdrew from the
previously common practice of everyone sharing the code of the systems that
were being run at the lab.

That led to his views that: 1) if any software is used by users, its code
should also be available to and modifiable by those same users; and 2) anyone
who tries to keep users from getting access to the code of the systems they
use (or uses legal means to keep them from modifying it when they do get
access to it), is the users' adversary.

If anything the Affero GPL fits the 1980s motivation better than the original
GPL does, since Stallman has always had the view that users of multiuser
systems, not only the sysops, should also have full source access. A user of a
SaaS app is basically the modern-era version of a non-privileged user of a
multiuser Unix system. I'm not sure why that use-case wasn't included in the
original GPL, come to think of it. My guess is just that it wasn't in practice
possible to do what Stallman objected to at a large scale, given technology of
the day. If you developed a proprietary app based on GNU software, installed
it as sysop, and then didn't want to share the source, your userbase would
generally be limited to one site. In _theory_ you could run something more
like today's SaaS: a central Unix system where you sold accounts but never
distributed the software. In that case Matlab could incorporate GPL'd
components without releasing their code by installing Matlab _only_ on in-
house servers. They'd sell people shell accounts on mathworks.com, but would
never let the software leave the building. In practice this wasn't done at
large scale, and instead any widescale usage required distributing the code to
sysops at other sites to install local copies (e.g. Matlab licensed its
software to departmental and corporate Matlab servers), at which point the GPL
would kick in if the software were built on GNU software.

The Affero GPL in a sense formalizes that previous status quo, by saying that
the GPL distribution requirements don't apply for in-house usage within one
site, but do apply once you're making the software available to users outside
the organization (even if "making available" is now via telnet or ssh or vnc
or http rather than binary distribution). The law around proprietary software
has also been moving in this direction, to consider hosted usage to invoke a
distribution-like copyright requirement such as "public performance", even if
no binary goes over the wire. For example, if I buy an NES game legally, but
then I sell accounts where thousands of people can VNC in to my server and
play it on an emulator, that is probably not legit, even though I am
technically never distributing the ROM to them (it never leaves my servers).
This isn't completely sorted out though.

~~~
codeflo
> I'm not sure why that use-case wasn't included in the original GPL, come to
> think of it. My guess is just that it wasn't in practice possible to do what
> Stallman objected to at a large scale, given technology of the day.

Stallman isn't exactly known for letting practicality and feasibility
compromise his ideals. Given that, as you said, the usecase was widespread
when the FSF was founded, I consider it much more likely that he considered
this case and didn't include it on purpose.

However, if you or anyone else has a good (older) quote from RMS on whether he
considers it evil to connect your free browser to a proprietary HTTP server,
I'd be very interested to see it.

The only thing I could find (actually rather recent, 2010's The JavaScript
Trap [1]) only argues that a free browser shouldn't run proprietary JavaScript
on your own computer, because that would violate your software freedom. It
says nothing to suggest that the HTTP download of _data_ from a proprietary
server is considered a problem.

[1] [https://www.gnu.org/philosophy/javascript-
trap.html](https://www.gnu.org/philosophy/javascript-trap.html)

~~~
mjn
> Stallman isn't exactly known for letting practicality and feasibility
> compromise his ideals.

When it comes to license choice, he's always been about a specific kind of
pragmatism: what will in practice produce more free software? The GPL, LGPL,
Affero GPL, etc. are means to that end employed in different situations. He
could be empirically wrong with some of his choices (and probably is), but I
don't see him as being particularly tied to the mechanism, vs. the outcome.

I actually think there's a decent argument that the existence of the Affero
GPL encourages more free software in specific niches. Some companies are
willing to release their SaaS apps under the Affero GPL who wouldn't have been
willing to release them under the BSD, LGPL, or GPL, because they fear those
licenses enable proprietary competitors. For example, Launchpad is AGPL. If
the AGPL didn't exist, my guess is that they'd just have stayed proprietary,
like GitHub has.

------
joezydeco
_" However, in the end it was the GCC developers that rejected Apple's willing
GPL contribution to GCC (still in the pre-GPLv3 days when GCC was GPLv2
licensed). The upstream GCC developers didn't want LLVM because of wanting C
instead of C++ code, GCC developers didn't like the modular and library design
of LLVM, LLVM wasn't formally "done" at that point, and there was some "Not
Invented Here" syndrome going on by the FSF developers."_

[http://www.phoronix.com/scan.php?page=news_item&px=MTU4MzE](http://www.phoronix.com/scan.php?page=news_item&px=MTU4MzE)

~~~
saurik
If you actually dig into the history of this, you see that the GCC developers
were actually quite positive (even about C++) and that merging parts or even
all of LLVM (even parts that conflicted: maintainers from gcc stepped up to
explicitly say "I worked hard on this piece, but I am mot attached to it:
let's throw it away if LLVM's version is better") came up quite often for the
following year (there was a lot of interest from the link-time optimization
people, as well as gcj for the JIT features), but in the end (much later) this
came down to most of the promises from Chris Lattner not panning out. (I was
remarkably happy that the comments on Phoronix actually got this right, so if
you read over the comments there you see a lot of discussion of this.)

> > The lack of FSF copyright assignment for LLVM is a problem. It may even be
> a bigger problem than what we think. Then again, it may not. I just don't
> know. What I do know is that this must absolutely be resolved before we even
> think of adding LLVM to any branch. Chris said he'd be adding LLVM to the
> apple branch soon. I hope the FSF assignment is worked out by then. I
> understand that even code in branches should be under FSF copyright
> assignment.

> This is a solvable problem, and has been pointed out to Chris repeatedly, by
> many people, at various venues, for over a year.

>
> [http://gcc.gnu.org/ml/gcc/2004-10/msg01146.html](http://gcc.gnu.org/ml/gcc/2004-10/msg01146.html)

> He keeps hand waving, saying that it's possible.

> Great.

> I say, enough grandstanding: it's not enough to be possible, it needs to be
> actual. If it is indeed actually possible to release LLVM under the GPL,
> then he needs to pick a version and GPL it. Then we can get serious.

> Make it so.

> He seems to be operating under the mistaken idea that the GCC community can
> go ahead and make plans around LLVM being free as defined by the GNU
> project, without it actually being so.

\--
[http://gcc.gnu.org/ml/gcc/2005-11/msg01065.html](http://gcc.gnu.org/ml/gcc/2005-11/msg01065.html)

~~~
codex
Apple will never, ever assign copyright to the FSF out of fears the code will
go GPLv3--or even to support an organization that advocates GPLv3.

------
RexRollman
Stallman's view on this was quite predicatable, as he is very consistant in
his opinions.

~~~
keithpeter
As is Mr Raymond, to whom Mr Stallman was replying.

Another HN thread pointed out a subsequent email in which Mr Raymond realised
that the GCC compiler did in fact have a sort of plug-in system.

------
NAFV_P
I have just thought of a hypothetical scenario:

Someone writes a revolutionary piece of software, then it is released under
....

0 > a closed source

1 > a bsd style

or

2 > gpl v3

.... licence.

I think the last choice would have a far more profound effect upon the science
and business of computing than the two alternatives.

EDIT: Oh, _tor_ is under bsd, how would things be if it were released under
gpl v3?

~~~
andreasvc
I think you forgot to provide an actual argument to back up that claim.
Personally I don't think the direct effect will differ depending on the
license, but it will have a big effect on how viable the software is in the
long term. Closed source will be abandoned when the original authors lose
interest, and with BSD code it is arguable that companies taking work but not
contributing back has a negative effect on the sense of community, but this is
of course hotly contested by BSD license proponents. One big example is the
Linux kernel which is GPL; but of course its success may or may not have
anything to do with its license.

~~~
NAFV_P
> _I think you forgot to provide an actual argument to back up that claim._

I purposely refrained from giving one because it is a hypothetical situation.
If you want a potential example I had a quick scroll through the GPL FAQ:

> " _All GNU GPL versions permit such combinations privately; they also permit
> distribution of such combinations provided the combination is released under
> the same GNU GPL version. The other license is compatible with the GPL if it
> permits this too._ "

Imagine BSD under GPL, since in this universe it is apparently used on Apple
OS's.

------
taspeotis
[https://news.ycombinator.com/item?id=7116144](https://news.ycombinator.com/item?id=7116144)

------
stephenr
Stallmans rhetoric and ridiculous hate for apple specifically is nothing new
and still makes no sense.

His argument about not being able to install modified versions of open source
apps on ios is either a blatant lie or sheer ignorance.

But that doesn't matter - his opinion is quite obvious as soon as he uses the
word "win".

It's apparently too horrendous for stallman to imagine a world where some
people support and use commercial software and some support and use open
source software and some support and use "free" software, without constantly
getting into a pissing match.

Stallman is frankly no better than a religious fundamentalist claiming
abortion and condoms are the work of the devil, and not only will they avoid
them, they will lobby governments to enact laws banning such items.

~~~
saurik
> His argument about not being able to install modified versions of open
> source apps on ios is either a blatant lie or sheer ignorance.

This is only true if you are willing and able to pay (and are allowed to pay)
Apple $99 to get into their developer program, for a limited number of
devices, to get access to a now closed-source fork of LLVM (the AArch64
support is still not merged, and no code from Xcode 5 has seen the light of
day now over four months later) that would let you swap in replacement code;
and then, even after compiling it, you wouldn't be able to freely redistribute
it to others without submitting it to Apple's store review process (which
might very well reject it for any number of reasons, including "similar to
existing apps", which is actually a documented rejection criteria).

~~~
stephenr
Membership is required to distribute via the App Store, not to build and
install to a device via USB.

There is also nothing stopping you installing the app onto others devices the
same way.

~~~
orbitur
> Membership is required to distribute via the App Store, not to build and
> install to a device via USB.

Nope, you can't install to a personal iOS device without the dev cert either.

Unless you've jailbroken the device.

------
protomyth
from the article's first comment:

"On the other hand, Stallman's goals (having the best compiler technology be
foverer a copylefted one) is perhaps achievable by having the GCC developers
abandon GCC, switch to working on a fork of LLVM/Clang relicensed to GPLv3
with continuous merging of Apple's work, and make that fork far superior to
Apple's version."

I assume this person means the changes would be licensed as GPLv3 because you
cannot just go and relicense someone else's code without the copyright
holder's permission.

Calling it "Apple's version" might be a tad bit offensive to the other
companies working on LLVM / clang.

~~~
bitkrieg
Plus this actually would be a step backwards since gcc's code generation is
still significantly ahead performance wise.

------
X4
If this is true, Stallmann has kept right with all what he said!

>> "by having the GCC developers abandon GCC, switch to working on a fork of
LLVM/Clang __relicensed__ to GPLv3"

>> Yeah, not allowed by copyright law. They aren't the authors, so they could
only GPL code they wrote.

If even the best developers of the world (allow me to exaggerate a little,
it's from my perspective anyways) aren't allowed to work on OSS, then this is
really a CUT of Freedom. I would love to see GCC people switch to LLVM GPL.

I see it this ways: GPL is an insurance that guarantees that whatever is made
with this code, will benefit this code in a way that everyone can take care of
that benefit.

Even though I'm new to this, I don't understand the hate towards Mr. Stallman,
he seems to be a fine man and his own strong opinions on a movement he has
started. There is nothing wrong with it, he's not beating someone up, just
because he's not of the same opinion, he's keeping the premise of his movement
alive. That's a good trait, not a bad one, esp. because he keep talking openly
about it. He's not wirting private confidential emails to discuss such things,
but makes it public, so that everyone can see. it. Imagine someone publicises
only one of your emails attached to your own name, it could be thrown out of
context and people could start a shitstorm, just because wrong word was used,
or because of your look . Takes guts to say your opinion, non-anonymously,
when you already have reputation in stack.

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

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

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

Stallman's original problem was essentially, "I had a broken car once and I
couldn't get the part I needed to repair it. That sucked, so all manufacturers
should provide everyone with all the information needed make any replacement
part, or turn my Beetle into a Porsche."

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

------
pjmlp
In a way I kind of agree with him.

On one way, it is clear that pure GPL software is not a way for whole industry
to function. Taken to the extreme, 100% GPL software, from what would software
developers live from?

Not all use cases can be applied to support, training or selling hardware.

On the other had the other open source licenses, promote the freedom of the
software developer, but not the end user.

Which is usually of no importance when the end user is a plain user.

However developers are also end users from the products of others.

I grew up in culture, where we had to pay for every piece of software we used,
except if we typed it ourselves from code listinings in magazines.

So in one extreme we have the everything free model, and in the other we have
the old model.

Currently we seem to be more or less in the middle.

I just wonder to which direction will the balance change.

~~~
drdaeman
> 100% GPL software, from what would software developers live from?

As usual, from their craft, the software development. GPL-everything scenario
doesn't mean there won't be need to develop software anymore.

It is quite usual to be paid to hack upon FLOSS code. Neither it seem too
weird to be paid to write new FLOSS projects. A customer needs a solution and
has money, an engineer has skills and needs money.

The only downside (or upside, depending on point of view) is that developers
won't be able to make $0.99-priced apps unless they really make it in mere
minutes of their time. They'll have to raise funding using some form of
threshold pledge system.

~~~
jiggy2011
The problem with a pledge system is that my $.99 on it's own won't make or
break the project and since I'm getting the software for free anyway it's more
rational to keep the money in my pocket. So you would have to impose it as
some sort of tax, which has it's own problems.

~~~
danieldk
On the other hand, you also know that if everyone applies the same reasoning,
the project will not be completed, and your loss is probably greater than
$.99.

~~~
jiggy2011
The problem is that most others will apply the same reasoning regardless of
whether I pay my $.99 or not.

------
rsynnott
I have to wonder if there'd be so much fuss about any permissive-license
project where Apple _wasn't_ a major contributor. I mean, you rarely see this
level of concern that the existence of the Apache web server or Python or
whatever will pollute the FSF's precious bodily fluids.

It might be just that GCC is such a flagship project for them, but, really,
the level of concern seems unwarranted. You'd think LLVM was the first
software ever to use a permissive license or something...

------
nzp
The biggest problem (possibly the only problem, but still a severe one) with
Stallman's views on software copyright licensing is that he seems either
unaware of, or unwilling to accept, broader social, economic and political
issues of our civilization. Software and processes around it, like any other
product of human social production, doesn't and can't exist in a social
vacuum. It's nice to be focused on a specific social issue, but when your work
scales to a certain level it becomes impossible to consider it in isolation.
Reading the comments on that article made me glad to see an LLVM developer who
chimed in (silvas) understands this perfectly and he articulated it quite
well:

 _We don 't do everything in public purely because of internal constraints of
the companies that we work for and those won't go away without significant
societal changes (i.e., the necessary changes vastly transcend the developers'
own attitudes on the issue: we're talking changes at the levels of entire
business models)._

[...]

 _> What about iPhone platform support?

I assume you mean that the platform is locked down?

Well, that's their platform. They make the rules for who gets to compile for
it. Now, you may say "well, they shouldn't restrict who gets to compile for
their platform!" and that's fine, but it's a different issue, one which goes
to the core of Apple's business model and the society that enables it and the
individuals that make up that society. Even if LLVM/Clang were to magically
become GPL'd tomorrow, the platform would still be locked down._

[...]

 _It 's myopic to think that the software is somehow the key factor here: the
assault on freedom in this situation is the incentive to keep it proprietary,
and that is a much larger issue. There is a similar assault on freedom from
the fact that their hardware designs are proprietary as well, and the
incentives are similar._

[...]

 _In my experience, Stallman 's view is extremely myopic because the real
impediments to free software are larger societal issues[1]. Within the hacker
community these issues don't really exist (Eric Raymond's essays cover this
well), and so the default is that code is free software (four freedoms), but
the other 99.99% of society is still stuck with archaic principles, and any
time that a hacker's paycheck comes from "the rest of society", they are
subject to a world where these issues exist.

[1] The GPLv3 "anti-Tivo-ization" wording is a perfect example that shows that
confining your view just to software is myopic. Why shouldn't we want the
entire device and all its chips to be free also? Why shouldn't the company's
internal discussions be done in public? The answer to these questions is the
same as the answer to "why does non-free software exist?"._

~~~
pavanky
The flip side of the story is that having RMS pushing for copy left software
relentlessly means you have an free OS + kernel and free development tools
that can run on practically any given device.

APPLE is one of the few companies that refuses to use GPL because they are
staunchly anti copy left. There are many companies out there that feel
otherwise.

Before I get too far off the road, the point I am trying to make is that the
business models ARE changing back to be more free. They changed in the first
place from free to proprietary in the late 70s.

~~~
mwfunk
Apple is clearly anti-GPL3, which is not the same thing as being "staunchly
anti copy left". They ship a number of GPL2 components, some of which were
essentially forked when the upstream project moved to GPL3.

Your last comment has been made a gazillion times over the last 20+ years but
it's just not that simple. There was no time in which the default business
model for software was free. What there was, was a time in which there was no
mass-market business model for software, period. There was no such thing as a
store you could walk into and buy software prior to the mid-'70s, and a much
larger proportion of software developers were scientists, engineers, and
hobbyists, who passed around a lot of common code, as they still do today.
It's not like there was some golden utopia back in 1973 where the world's #1
spreadsheet application was free software, because such things didn't exist
back then.

------
thatthatis
If you care about free as in freedom, copy middle is how to get it.

Copy left tears from you ownership of your incremental work, it makes your
work an ideological prisoner of the commons.

Copy left ensures a certain degree of openness, but open does not equal free.

Only copy middle is truly free software.

