Why the GPL sucks

I have a lot of respect for the work Richard Stallman has done for software. He’s written some really awesome things, like Emacs and GCC. And he was one of the first to get people thinking about open source and free software. He was a pioneer in his field, and an all-around smart guy. And then…

Which, hey, cut him some slack, right? The guy wrote Emacs! If he wants to put a disk platter on his head to celebrate, then… that’s cool.

But then… things got weirder and weirder. First, he came for X Windows, which is totally free and open-source. Then, he started rallying against MS’s efforts to turn Office into an open standard. Now, he’s stirring the pot against the free and open-source Mono project with FUD that’s been debunked again and again, prompting even Microsoft to weigh in, and yet Stallman still goes on in his own little “we need a comprehensive patent license” world, completely oblivious to the comprehensive patent license right in front of him.

All that to say, he basically created OSS as we know it today, but that’s no reason to sit back and watch him try to actively destroy it. When Microsoft is the one promoting open standards and open source, and Stallman is the one spreading FUD about pure OSS stacks and pure open standards, that should cause someone to think “Hey wait a minute, this seems a tad bit backwards.” What we are now seeing is, to a large extent, that the two teams have switched ideologies. Stallman, who spent so much of his life opposing big corporations, has forgotten whatever view he used to hold, and is now opposing Microsoft just because, even when it totally contradicts his own former principles.

Which brings us to the GPL. I don’t even want to get into the GPLv3, because that’s been endlessly debated, and as it turns out nobody really important uses it. So I think there’s a certain widespread de facto consensus within the FOSS community that it’s not a very good idea. So when I say “GPL” I really mean v2, because that’s the only one with any sort of widespread use.

For those of you who don’t know, the GPL says (as an extreme oversimplification) that you have to make the source code available to a piece of software when you distribute it. So if you took the popular GCC compiler, and modified it to be faster, and sold it, you would have to distribute the source code of your modification along with every binary copy, and now everybody knows how you made it faster, and you have a hard time making any money, and maybe go out of business. [This is an extreme simplification. I’m not going to get into patent law and trademark law, which are sometimes used (sometimes ineffectively) to make the source code you distribute difficult to actually use.]

Now, you may say “They’re profiting from GCC! People worked hard on that!” And that is very true. It’s rather unfair for other people to profit from your work. But we must be consistent. Red Hat and Novell make loads of money off other people’s work; they simply do it in a way that complies with the licenses (more on this later). And they’re generally rather well-liked in FOSS circles. So profiting off other people’s work can’t be very bad if we let Canonical get away with it and we still like them. It’s got to be an ideological thing. So what can it be?

Releasing FOSS software is like putting a toilet on your lawn with a sign that says “Free”. The first version is probably a pretty shoddy toilet. The author made it to scratch his own itch. 99% of the time, he’s not interested in helping you plunge it. He’s not interested in modifying it to be a wheelbarrow. He made it to solve some particular problem, he decided maybe somebody else could find a use for it, and he put it out on the lawn. His itch has been scratched; his problem has been solved; the thing is done.

Except not. If I come along and want to make the shoddy GPL toilet into a wheelbarrow, if I pour blood and sweat and tears into the wheelbarrow, if I do original research and and custom-mold frictionless ball-bearings and spend millions on case studies and have a team of people… I must also put it out on my lawn for free because somebody else did that with the shoddy toilet I started with. This is called “protecting your freedom.” Wait, what?

Okay, that was a contrived, straw-man example. What actually happens is that very, very rarely does blood and sweat get poured into shoddy GPL projects because everyone knows you’re going to have to give it away. It does happen in cases where somebody (Linksys, I’m looking at you) doesn’t understand how the GPL works, and ends up getting forced to give the software away. It does happen in cases when there’s some other developer looking to scratch a significantly more complicated itch and uses the shoddy toilet as a stepping-stone. It does happen in cases where somebody backs the project as a sort of goodwill/advertising move. But by-and-large, shoddy toilets never make it into polished wheelbarrows.

Now let’s be clear. Neither copyleft nor BSD-style licenses are going to help you much, as the developer. A copyleft license restricts the way in which somebody downstream can use your work, and a BSD-style license basically lets them do whatever they want with it. In some cases maybe you have a cool dual-licensing strategy or negotiate contracts with Red Hat or something. But in the normative case, the only difference is that either cool wheelbarrows exist or they don’t, and neither of these choices have a net positive effect on you. (The fiction, the idea that somebody will make an awesome wheelbarrow, and give it away, is simply that: a fiction. Any game theorist should understand this.)

But there is a net effect on software development. Who makes money off GPL code? We go back to Novell and Red Hat, who test and package this software. And we see a trend–GPL code helps software testers make money. It helps QA people. It helps the people who answer the support phones. It helps everybody except software developers. Oh, maybe Google will pay them a salary as a goodwill gesture. But it’s really, really hard to make money from developing FOSS. You can make money supporting it. You can make money testing it. But no money developing it.

Back to the BSD model. Who makes the money now? Software developers. The people who develop and design the wheelbarrow clean up. Now granted, the shoddy toilet creator gets nothing. But the field as a whole does a lot better. Now the developers are calling the shots, instead of the QA and support people. Now you can get a job designing wheelbarrows, and so on.

That’s the practical argument. Now here are some ideological ones.

First, copyleft licenses like the GPL are widely considered by their proponents to be “freer” than BSD-style licenses. This is the wrong word. The word “free” means this:

not under the control or in the power of another; able to act or be done as one wishes

As we’ve seen, what the GPL actually does is it gives you, the author, more control and power relative to BSD. Maybe this is good; maybe this is bad. But it is certainly not more free. By definition it is less free. And anybody who says otherwise has gotten lost in their own logic.

What copyleft proponents actually mean when they say “free” is they want people to behave well. They want upstream people to be recognized and compensated and they want downstream recipients to release their code so that the whole community can benefit, and they want people to be “fair” to each other, and so on. This is all fine and dandy, but it is not freedom. It’s freedom insofar as downstream recipients are “free” to do what you like, and not free to do things you don’t like. And unlike proprietary licensors, you like some very good things–open source, reusable code, etc. etc. And you dislike some very bad things–people stealing other people’s work, not giving credit where credit is due, etc. But don’t confuse this sort of utopia with freedom, because they are miles apart. Freedom means that somebody has the ability to do things you don’t like. This is what we mean by “free speech”, the ability to say things others don’t like. This is what we mean by “religious freedom”, the ability to practice things that others don’t like. The GPL gives users the “freedom” to do what you like. This is a totally different cup of tea.

Hopefully you’ve seen that horrible bit of bytes that comprises the “You wouldn’t steal a handbag” nonsense. The key difference between stealing a handbag and stealing a film, is, of course, that in one case we’re short one handbag, and in the other case, we’re not short one film. The MPAA and friends like to argue about “lost sales”, and so on, but most reasonable people agree that this is by and large a bunch of nonsense.

This same logic applies to software. When somebody forks a project and makes it proprietary, they haven’t “stolen” the project. All the code you’ve written is still free and open right in front of you. What they’ve done is improved what you’ve built and given people another choice (namely, a proprietary one). You’re not out anything. You’re not short anything. Now granted, it’s not very nice, the same way that downloading a movie off bittorrent isn’t very nice to the movie industry. But the only way you could be “harmed” is if people start switching to the proprietary fork, and your software loses popularity. And if that’s your concern, I’ve got news for you: writing software is a horribly shoddy way to become popular. Take up a different hobby.

Now you may say “But wait, I have some sort of Author’s Right[TM].” And that’s very true. You do have an author’s right. But other people [should] have an author’s right to the code they write. And if somebody makes a serious advance on your shoddy toilet then they should really be able to license it how they see fit. And so if your project is a shoddy toilet project, you really shouldn’t exercise your author’s right by using the GPL, because that prevents other software developers from properly exercising their author’s right [back to that definition of freedom thing again].

At the base of it, I think, the GPL is selfish. When you GPL a project, you’re saying “This is mine, and if somebody else changes it, they’d better give it back to me.” It’s cloaked in better words of course (“This project is the community’s and you’d better give it back to us“). But for me, anyway, saying that would be lying to myself. More often than not, the first release has no community, so there’s just the developer.

This whole time, we’ve been dancing around what constitutes a “modification” and a “work”. Any real software developer knows the distinction between one software package and another is a bit arbitrary. At the end of the day, a microprocessor runs through some statements in order, and it doesn’t know where one package begins and another ends. Packages are purely an arbitrary construction for human minds. And now we get into real trouble.

Say we have two software packages on the same hard disk. Those are clearly separate works. How about two packages as part of a system (like cc and ld)? How about two binaries that communicate via pipes? That communicate via shared memory? How is that different from two libraries that are dynamically linked? And how is the latter any different from being within the same compilation object? How do we deal with “modules” in a dynamic language like Python? Do we treat them like seperate processes, seperate libraries…? How do we deal with “linking” in a JIT-type language? Can we license a DATA assembly section under a software license? If so, can we release text under the GPL? And on and on it goes.

The FSF have acknowledged some of the madness, and so we have a proliferation of licenses like LGPL, GPL, Affero, and on and on it goes. The GPL treats the software “package” as a unit, and any changes to the package must be open. The LGPL uses the “library” as its base unit, and you can link an LGPLed library into a proprietary software program, with some very complex restrictions that basically let people change the version of the LGPLed package you linked to. Affero tries to go the whole nine yards, saying that if you run Affero code on a remote server and let people make queries of that server over the Internet, that counts as “distribution”, and so you must release the source code. (How that is enforceable I have no idea.) As best as I can tell, this stemmed from the sentiment that “How dare Google make gobs of money by making an end-run around the GPL by running software on their own servers,” which is a level of selfishness on the FSF’s part that I hope is self-evident.

But of course there’s no such thing as a library, or a package, or even a web server, except as a legal fiction. There are just x86 instructions. Whether we separate the code by a thread ID number or by an undersea cable, it’s just code.

And here is where we’ve arrived: we have “free” licenses that force developers to construct large and complicated legal and technical barriers between the resources they have available to them and the problem they want to solve. What started out as a shoddy toilet on the front lawn has become a complicated and technical and legal jungle of licenses and compatibility and barriers and linking and languages and words and terms.

And I’m tired of it. This is not the software movement I signed up for. I didn’t sign up to let testers and QA people profit off the work of developers. I didn’t sign up to create a whole series of artificial barriers to prevent people from using my code. I didn’t sign up for misguided and deceptive rhetoric about how “freedom” needs all these complex restrictions.

I signed up to put a shoddy toilet on my lawn, in the hope that some poor soul would find it useful.

---

Want me to build your app / consult for your company / speak at your event? Good news! I'm an iOS developer for hire.

Like this post? Contribute to the coffee fund so I can write more like it.