25 July 2009 by Published in: rants 9 comments

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…

Saint iGNUcious

Saint iGNUcious

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.

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

Comments

  1. Sat 25th Jul 2009 at 12:38 am

    Nice blog post: not sure I agree with you 100%, but it’s at least challenging and interesting.

    First of all, the GPL isn’t “giving it away”, and although you addressed that pretty well, I think you ended up condemning it a bit more harshly than it deserves. The FSF seems to actively chafe against that reality, too, which is why allowing the SaaS “loophole” surprised me: it appears like someone in the FSF with veto power has a bit of business sense after all. Or their lawyers couldn’t figure out the right way to word it. Or something.

    More importantly, though, is that part of the reason I use GPL for some projects is because that’s the payment *I* want for my initial work: I want to know that if you muck with it and you make something new out of it, I’m going to get to be able to see the source code to see how you did it. Or it’s because I’m doing something which I see as generally useful for humanity (like a programming language), and I don’t want someone privatizing and shrink-wrapping it and making it proprietary. And that “someone” that I’m stopping may well be a future-me.

  2. Sat 25th Jul 2009 at 12:54 am

    Oh, and I have to call out this mixed metaphor: “The first version is probably a pretty shoddy toilet. The author made it to scratch his own itch.”

    You scratch your itches with shoddy toilets? That just *can’t* be sanitary…

  3. Sat 25th Jul 2009 at 2:46 am

    First, yes. Stallman probably shouldn’t be making public appearances representing anything. There was a lot of fuss on Planet Gnome recently after he made sexist jokes as part of his talk at a Gnome development conference.

    The GPL was Stallman’s way of providing a method of preserving the “share and share alike” programmer mentality of olden days before closed source became popular. It’s not as free as BSD, but that’s not the point. If someone wants their code to be useful to other people but doesn’t want someone else making money off it without contributing *something* back, that’s fine. If someone else doesn’t care, this is also fine. If you don’t like the GPL mentality, don’t write GPL code.

    The GPL *is* selfish for the original developer. The contributors are selfish also; they won’t contribute if they feel they aren’t getting something good out of it. Much like capitalism, it usually works best when everyone is just looking out for themselves. Linus Torvalds has acknowledged this several times. http://lunduke.com/?p=725

    Um… also, Novell and Red Hat employ developers who write quite a lot of fairly popular GPL code. Don’t underestimate the value they provide in terms of non-dev contributions either; Linux wasn’t always this easy to use. They’re also beneficial to the community in part because they provide legal cover for several projects if there’s a patent lawsuit.

  4. Drew Crawford
    Sat 25th Jul 2009 at 6:17 am

    @James

    If you don’t like the GPL mentality, don’t write GPL code.

    Of course. But there are reasons why I don’t like it. I don’t dislike things just because. This article serves to explain those reasons.

    they won’t contribute if they feel they aren’t getting something good out of it

    This is my point: choosing GPL over BSD for a software project means less software gets written, because less people will write it.
    Of course, that may not be your goal (to get software written). You may want money, or accolades, or street cred, or whatever. In which case you use a license that (you believe) will get you those things. But then you don’t hold that license up as the last bastion of freedom, as ideologically pure, as the savior of software from all the world’s ills. And you certainly don’t put all that nonsense into its preamble.

    Um… also, Novell and Red Hat employ developers who write quite a lot of fairly popular GPL code

    Most open source projects wouldn’t even blink if RH or Novell went under tomorrow. Oh sure, everyone would blog about it, and maybe someone would have to go to the trouble of moving Mono to the SCM repo of the next corporate sponsor.
    On the other hand, if the Linux kernel packed up and left, Novell and RH would be high and dry.
    No part of that is a symbiotic relationship.

  5. Sat 25th Jul 2009 at 10:48 pm

    So perhaps GPL means less software gets written. Again, so what? I want users to be able to help each other out by hacking on the software; closed source forks don’t tend to be amazingly useful for the community.

    The only person I know of who considered GPL the last bastion of freedom (and who put all that stuff in the preamble) is Stallman, who we’ve already established is a horrible representative. That doesn’t make the license itself bad (well, not v2); it just means there is an additional level of crazy associated with that particular license. But it’s there, and it works decently.

    I’m pretty sure RH and Novell folding would cause a larger shakeup than you imply (combined, they sponsor about 20% of kernel development; individually they’re still in the top five, ahead of IBM and Intel), but no, there likely wouldn’t much permanent damage to projects. This is true about BSD-licensed projects also.

    Using your same example, if a BSD-licensed project packed up and left, many companies making money off it would also be relatively high and dry. That’s not exactly a symbiotic relationship either.

  6. Wed 06th Oct 2010 at 8:19 am

    The other way to make money with a GPL or AGPL project is to also allow commercial licensing, for a fee. And if you want to collect that fee, you can’t have anyone else’s GPL or AGPL code in your project. Which is interesting.

    TRiG.

  7. Ricardo Santos
    Wed 29th Dec 2010 at 4:19 pm

    I think the main point of the article is the hypocritical saying that GPL is about freedom, when in fact is about control. On that I agree.

    The second point is that the ones making the profit are not the developers but the distributors, support and QA companies. Again agree.

    Third point is that it does not promote the use of software as a building block to better software. Agree 75%.

    I might add a 4th point, GPL is often used to have free labor and testing and then change the license and close the source. This is possible because no money was exchanged thus the original copyright holder can change the license whenever they like.

    Overall GPL is a shitty license from a developer point of view, but a great license if you want to take advantage of developers. The great thing is that there are so many developers that believes the false freedom statements of Stallman and company.

  8. Mike
    Wed 14th Dec 2011 at 4:43 am

    “Overall GPL is a shitty license from a developer point of view, but a great license if you want to take advantage of developers. The great thing is that there are so many developers that believes the false freedom statements of Stallman and company.”
    100% agree.
    GPL is a trap. Their speech about freedom is a complete joke, a real nonsense.
    Oh I’m one year late, never mind, nothing changes.

  9. Fri 28th Dec 2012 at 7:28 pm

    I found this article so intriguing that I’ve permamarked it for posterity. Now, this web page will hopefully survive this website :) http://www.permamarks.net/grabbed_urls/OQhBYg/sealedabstract.com_210.htmlz

Add comment

Copyright © 2011 Drew Crawford, All Rights Reserved
Powered by WordPress

Page optimized by WP Minify WordPress Plugin