Skip to content
May 6, 2008 / cdsmith

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:

  1. MySQL can afford to hire a lawyer, and you probably can’t.
  2. 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:

  1. Financial power. You can’t hire a lawyer, a company profiting from their software can.
  2. 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.
  3. 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.

What now?

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.


Leave a Comment
  1. ben / May 6 2008 10:46 pm

    i think the lesson here is that the GPL ends up being very close to LGPL when your library implements a well defined interface and can easily be subtituted. assuming none of the non-GPL components apply any restrictions on the client the client can simply substitute in a GPL component and as long as they don’t distribute it they are adhering to the terms of the GPL. i’m not a lawyer but that is how i understand the GPL works.

  2. liedra / Jul 30 2008 3:15 am

    I think you’ll be surprised about how many people who choose the GPL for their project really have no idea what the actual requirements of that license are. I used to work for and one of the email response boiler plates we had was one that basically said “you obviously don’t understand the requirements of the GPL” (freshmeat doesn’t deal solely with GPL’d software but we as staff were required to make sure the license they chose on the site matched the actual licenses, and we found so many bizarre ideas about what the GPL was that we had to make a boilerplate just for that — one example was one that basically said that because the software was released under the GPL it meant “you can do whatever you want with it, because that’s what the GPL means, freedom!” which is obviously wrong). I think a lot of those idealists really are just that, idealists! They’re caught up with the GNU religion, essentially, latching on to the concept of “freedom” without understanding that the GNU version of freedom is a lot different from the normative concept of freedom!

    Anyway, I found this article really interesting :) Thanks!

  3. Stefan Wagner / Oct 22 2008 12:31 pm

    I had very similar thoughts about MySql too (back in 1998, when I first met it). Fortunately I found postgresql matching my needs much better.
    The way MySql deals with the GPL is very unclear. I don’t like it. But I didn’t find a second usage of similar kind.

    Revoking a license:
    The license has to somehow fit to national laws. AFAIK, a license is considered a contract in Germany. So if I publish some work under the GPL, and you download it from Sourceforge, and start using it.

    Now I decide to revoke the software. I delete it from freshmeat, but you are using it on the basis of our contract, which is the GPL. So this contract can’t be cancelled from a single side.

    Mr. C would like to use the software too, but I’m not bound towards him, to publish the sourcecode. And you aren’t too. If you like, you could publish it on your own, but Mr. C can’t force you to do so.

    Of course I may use a complete different, second license too on my software, if I have written it from scratch.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: