When I buy music protected by DRM, the seller intends is to stop me from making copies of songs. When I use software that is licensed under the GPL, the developer intends to stop me from making the software "closed," or non-free. The intentions obviously aren't even slightly similar, but the consequences are. Both the GPL and DRM want to restrict my use, and re-use, of the music or source code that I obtain. Neither does what it was designed to do. Both have unintentional harmful effects.
The GPL has unintentional harmful effects
I have been discussing the effects of preventing people from copying, changing, and building on a program. I have not specified how this obstruction is carried out, because that doesn't affect the conclusion. Whether it is done by copy protection, or copyright, or licenses, or encryption, or ROM cards, or hardware serial numbers, if it succeeds in preventing use, it does harm. -- Richard Stallman
In trying to stop you from copying, DRM introduces many unintentional harmful effects. CDs with copy-protection typically won't play on PCs, and may even refuse to play on some modern car stereo systems. Whenever you introduce restrictions, there are side effects -- and so it is with the GPL.
The first side effect of the GPL comes from its legal complexity. The GPL scares business users and their legal departments, to the extent that many have a policy that boils down to "no GPLed software may be used anywhere in this company." They are unsure of the conditions under which they might be obligated to re-license their own proprietary source code under the GPL, and for the sake of competition they want to stay as far away from those conditions as they can.
The main harmful effect of the GPL is the "gated community" it creates. When you release your source code under the GPL, the only people who can re-use it are those who also license their software under the GPL. GPL users are quick to complain when other licenses are "incompatible" with the GPL, but the GPL itself is incompatible with just about everything.
If I'm part of the GPL community, I can re-use code from any other piece of GPLed software, no matter how small and insignificant that piece of code might be. It might not be a large part of my program: I might, for example, be taking a compression routine to add to my new open source Web browser. Then I just add credit to the documentation.
The Readline library implements input editing and history for interactive programs, and that's a facility not generally available elsewhere. Releasing it under the GPL and limiting its use to free programs gives our community a real boost. At least one application program is free software today specifically because that was necessary for using Readline. -- Richard Stallman
What if my Web browser is proprietary? I'll have to write my own compression routine (or hack around the restriction in some odd way, like making the compression routine into a stand-alone GPLed program and then calling it from my proprietary program), or make my program free software. "Well, that's good," you say, pointing at the Stallman quote above. Ah, but what if I want to release my program under the BSD license, or some other alternative open source license? Then I'm screwed. I can't use your GPLed compression routine, unless I try behave in the same way as the proprietary software maker might -- but that would be frowned upon.
The rest of the open source community is standing at the gates of free software, denied access to the masses of GPLed source code within. Is this free-as-in-freedom?
The GPL doesn't do what it was designed to do
In the GNU project, our aim is to give all users the freedom to redistribute and change GNU software. If middlemen could strip off the freedom, we might have many users, but those users would not have freedom. So instead of putting GNU software in the public domain, we 'copyleft' it. Copyleft says that anyone who redistributes the software, with or without changes, must pass along the freedom to further copy and change it. Copyleft guarantees that every user has freedom. -- Richard Stallman
DRM doesn't really stop me from making copies of my music: as long as people want to share their music, they will find ways to circumvent DRM measures. Likewise with the GPL. You can't force some people to keep their software free: they want it to be proprietary, and they will circumvent the license.
Earlier, I alluded to "hacking" the GPL's restrictions. Here's an example. Say someone has produced a program under the GPL that takes a document from any version of Microsoft Word as input, formats it as HTML, and spits it out again. I want this functionality in my proprietary word processor, Wordwalker 2004. I have two choices: write my own version, or release Wordwalker as free software under the GPL. Right? Wrong. I can just include the GPLed converter program (with its source code) on the distribution media with my proprietary software (the GPL specifically allows this). I can run it silently as a subprocess (this is a grey area, but is generally believed to be allowed by the language of the GPL), sending it the Word document files and using its output in my proprietary program.
This is not what Stallman intended. I would have made use of advances made by free software, and yet my users would not ever get to see my own source code. If they want support, they've still got to come to me -- I could even stop them from hiring someone else to make changes to the source of the document conversion component, by making my proprietary routines reject any version of it that has the wrong checksum.
Want more? Let's look at the KDE/QT situation. KDE source code is released under the GPL, but it is linked to Trolltech's cross-platform QT library. GPLed versions of QT are available for X11, Macintosh, and embedded platforms -- but if you want a Windows version, that'll be $1,550, please. It's another GPL exploit: GPLed code links to software that is proprietary on one platform, and suddenly that code isn't looking so free any more.
There is no way the GPL can stop this sort of thing from happening, any more than it can stop me from writing a free software program that relies on the proprietary Windows API. But the worst is yet to come.
More and more often, the applications we use aren't on our desktop -- they're on someone else's server. Say I'm running a Web site called Tell Your Fortune. All my site does when you visit it is run a GPLed version of the fortune program that I modified to listen on port 80 and respond to HTTP requests. Can you get the source to my modified fortune? No. I haven't redistributed it in binary form, so you have no rights to the source.
This could be happening all over the Web. You could be relying on heavily modified versions of GPLed software every day: at Google, at Amazon, at eBay -- you have no real way of knowing. You are a user of the software, but you have no access to the source code.
You can't stop undesired usage, so leave it open
If you can't stop people from sharing your copy-protected CD, then why inconvenience your normal customers? We have seen how crafty proprietary users can make use of GPLed code without distributing their changes, and we've seen how the GPL stops others in the open source community from re-using your code. Why restrict your friends for the sake of non-working measures against your enemies?
This is where BSD and MIT-style licenses come in. These are licenses that, basically, say you are completely free to re-use the source code anywhere you like, even in proprietary software, as long as you give credit to the original authors.
Just imagine not having to worry about licenses any more. If I want to take a compression routine from BSD-licensed code, I can just use it, and add credit to my documentation.
You might notice the parallel with how people in the GPL community can re-use GPLed code: put simply, BSD-style licenses knock down the community's gates and let everyone use open source code for whatever they like. Here's the ultimate test of freedom: can I use GPLed code in my BSD-licensed program? Can I use BSD-licensed code in my GPLed program? (No I can't, and yes I can).
If you really want to share your code instead of jealously guarding it, use BSD-style licensing. If you care about receiving credit in other people's documentation, then you could even put your source code in the public domain! Imagine an open source community where software can be re-used like SQLite's public domain database code:
Anyone is free to copy, modify, publish, use, compile, sell, or distribute the original... code, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means. -- SQLite copyright
That's true freedom, and that's true open source.