Why licenses don’t matter (and why they do)
There’s a fairly long history in the free software and open source communities of being very interested in licensing. It’s always been ironic to me, since free software is supposed to be about not exercising control over how people use your software. Most recently, I read this article on whether the GPL can be “revoked” on a project to which it has already been applied. There are any number of other issues: Can this library be used by that project? Can I relicense your code to a less permissive license without making any substantial changes? And so on…
I am of the opinion that the legal meaning of a license is completely irrelevant. It doesn’t matter what someone has the legal ability to do. It’s necessary to pay attention to the social influence and intentions of others.
Example : MySQL
Let me make the point by giving an example. In fact, there’s one example that covers this very well. Think about MySQL, the database company. Yes, they are most definitely a company, with all the overriding profit motive that implies. Profit motive isn’t bad; but it is a motive that might not align with your best interests. They wrote this database, and released it under the GPL. It made a big name for itself by being a “free” database. In fact, at least until very recently, it was a really crappy database that couldn’t do basic stuff like transactions or handling reasonably complex SQL; the only reason you’ve ever heard of it is that it is “free”. But it’s also dual licensed as a commercial database; and here’s the rub: ultimately, the GPL nature only matters if MySQL wants it to matter. They let it matter when it means free publicity and a cult following; but when they see the opportunity for a profit, the GPL suddenly seems to grant you a lot fewer rights that you thought it did. The legal and semantic machinery going on is rather elaborate; but it is not the point. It’s only the excuse. What it comes down to is this:
- MySQL can afford to hire a lawyer, and you probably can’t.
- People accept MySQL as the expert on what “their” license means.
What this means is this: if you use MySQL, you accept that you are at the mercy of MySQL’s whims. If they decide you should give them money, you give them money. In fact, it goes further than that. As a test, some years ago, I approached a MySQL representative by email about one of the more peculiar and ridiculous re-interpretations of English words that they put forth. In particular, I asked this. Suppose I had an application (not free software itself) written in Java using JDBC; and that I distributed it with PostgreSQL, but since the application just uses simple SQL and JDBC, someone who uses my software might conceivably download MySQL and use that instead. In fact, suppose I have customers who I suspect have done just that, since they prefer the administration tools for MySQL. The response was a rather obtuse legal threat: something like “We can’t give you legal advice, but it’s always safest for you to buy a license. The protection you get will be worth the investment.” They want me to buy protection. To bastardize a line from a Patricia Briggs book: And yes, just like the mafia, MySQL only protects you from themselves.
So if you have a free software application and the company doesn’t see any other reason to make a threat, then you may use MySQL. But the other rights in the GPL are lost. If you download MySQL and it interacts with some other (possibly non-free, possibly threatening to MySQL) application using publicly specified interfaces, MySQL feels they have the right to sue someone. If you modify MySQL and try to distribute your changes, who knows what would happen? And don’t imagine for a second that you could get away with forking the code, which is in the end the most fundamental free software right. If you had any success, there would be lawyers knocking on your door before you could sneeze.
Lessons from the example
So this is the situation we’re in. You may have legal rights granted to you by a document like the GPL (or BSD, or MIT, or Creative Commons, or…) But because some other party holds some kind of power over you, you can’t really trust your ability to exercise those rights reliably. Of course, there are many kinds of power involved here. Not everyone is motivated by profit. Some people are motivated by social status, or even a sincere desire to do good. Power might include:
- Financial power. You can’t hire a lawyer, a company profiting from their software can.
- Presumed authority. Since the software provider chose the license, people take their word on what it means. This is regardless of the fact that in the free software world, virtually no one except major figureheads actually writes their own licenses.
- Social expectations. Even if I can get away with doing something that the author of the software doesn’t like, if they are going to be upset my it I’ll probably take a pass. It would take a definite jerk to ignore the wishes of the person who did all that work and made it freely available to you.
But whatever the kind of influence being wielded (and some of those kinds of influence are not entirely bad) the fact remains that you can’t tell everything about your ability to use software by the written license.
So how did we get here? What do we do?
I think how we got here is that we’re computer programmers. Computer programmers, by nature, tend to look for simple and unambiguous rules that define what is possible. The license pretends to be that, and we miss that it’s a false set of rules. It’s a set of rules only in theory, in an idealized sort of half-egalitarian, half Ayn Rand world, where everyone acts in their own best interests and has an equal understanding that others will too, and everyone is on equal footing in terms of the power they have to act in those interests. Legal absolutism simply doesn’t translate into the real world, as much as we’d like to see it happen.
Instead, we need to realize what people have known since the beginning of time – but we’ve tried to forget. It matters who you are dealing with. We should take the time to find out the motivations of the people who build the things we use. In particular, there are different kinds of groups of people building free or open-source software. At least a few of them are as follows. (Of course, I’m grabbing archetypes that no one will meet exactly. There’s no intention that you can’t span a few of these groups.)
- Commercializers. These are people who completely believe in their ability to turn a profit by building open source software. They are often the dual-licensers, GPL+commercial, or sometimes the support sellers, or sometimes the people who build service businesses and use their software to provide those services. In any case, the open source side is likely to use the GPL or a similar restrictive license just to stop the competition. In its purest form, this sort of group doesn’t care about you unless you are making them a profit. Maybe you’re actually paying them. Maybe you’re getting your customers to pay them. Maybe you’re giving them positive reviews and claims of popularity that they can use to take other people’s money. Just make sure your intentions don’t conflict with their commercial interest. This is the most dangerous group, as business sorts tend to believe it’s a perfectly normal “strategic decision” to make other people miserable.
- Idealists. Some groups are motivated by the pure idea that software should be free. This certainly includes the entire GNU organization, and a number of others to boot. The GPL license is pretty popular here. The motivation is to make more software free. If you aren’t building free software, this might be a good time to ask yourself if taking advantage of these people’s work is the right thing to do. On the other hand, very few people are really extremists here. No one is going to hate you for using gcc to compile and build closed commercial software; but you might be careful if the project is newer, and particularly if it’s a library licensed under the GPL, which is a clear sign that the authors don’t want you to do that. (The legal meaning doesn’t matter; it wouldn’t be okay to use readline in a commercial product even if it turns out the license is unenforcable.)
- Social Groups. Often, free software is built by groups who are just having fun. They want to develop ideas, work with other people, but avoid having obligations to customers or dealing with business concepts like marketing, payroll, etc. Most of these groups will license software under the BSD or another very permissive license. In less software-oriented groups, Creative Commons is also popular here. They don’t care what you do with their software, so long as you don’t try to keep them from doing as they please. Many groups of this form will be happy to hear that you are finding their software useful. The biggest way to piss these people off is to adopt an attitude of entitlement. If you avoid that, you’re fine.
- Academics. This last group is interested in writing the software for the sake of writing it, learning what they can from it, and moving on. They will be thrilled if you use their software to solve other interesting problems. (And I mean interesting in the academic sense.) If you just have fun, they won’t mind. If you commercialize it, expect an attitude of profound apathy. There are academics who are interested in commercializing their work, but they don’t release their software with free licenses. Most academic work tends to be released under BSD, MIT, or similar licenses. In fact, it’s worth noting that both of those licenses are named after the major universities where they were originally written.
Licenses matter after all
While I started this rant by saying that licenses don’t matter (in terms of the legal rights they grant you), it turns out that they actually matter quite a bit (because it helps you tell what kind of group you’re working with). This is important for using a project. It’s also important for getting involved in a project.
Here’s a true story. A few years back, I got involved in a group that was building libraries for C programming on an embedded device. I write a lot of code for dealing with an LCD controlled, and built a graphics library and a user interface library on top of that. Then one day, someone wanted to use our libraries to write a commercial application for these devices. There followed a massive debate, wherein I realized that I had completely different goals than anyone else. I’d just been having fun. Others were talking about setting up a commercial dual license, deciding how to apportion the profits; or else insisting that we had built this to encourage free software, and we shouldn’t just give it away to people who would make money on the backs of our efforts.
The project had been licensed under the GPL. In retrospect, I should have asked more questions about that before I got involved. I just assumed it was the easy default choice, since it’s the license more people have heard of. It turns out that some people in the project thought it mattered quite a bit. Lesson: the license is a good way to get an initial idea of the kind of people you’ll be working with in a project.
Anyway, that’s my rant.