Last week, I posted an article that pretty much started with “this is not about a legal interpretation of the GPL.” Therefore, of course, 80% of the people who commented on the article did so to give me their interpretation of the GPL, or to explain why my interpretation was incorrect. So much for that.
You are not Perry Mason
Let me, once more, explain why the legal interpretation of the GPL has no bearing on the issue at hand before addressing some of the issues that were raised in the comments. The positioning of the GPL with regards to derivative works has not been tested in a court of law. This means that there is no accepted definition of what a derivative work is in this context is simply undefined and can, by some account, lead to, shall we say, “interesting” conclusions. For this reason, my opinion on this matter, or Matt’s, or anyone else’s, is entirely meaningless, at least from a legal perspective.
You could say that Matt’s opinion counts, because he wrote the software and he should have the right to decide how his software is distributed and under what rules.
I couldn’t agree more—except for one minor detail: Matt made his decision when he chose to distribute WordPress under the GPL. From then on, both he and any user of WordPress are bound by the terms of the license, and not by what anyone thinks. Matt doesn’t enforce the license: that’s for a court of law to do. Therefore, what he thinks at this point only has value, from a legal standpoint, if a competent court determines that the terms of the GPL agree with him.
This, incidentally, is one of the biggest concerns that I have with the GPL. It’s a license that enforces a very particular meaning of “freedom” whose nuances a developer may simply not understand. Case in point: Matt may well believe that themes must be released under the GPL as derivative works, but there is no real case law to back this belief. The FSF says so, but they are less than intellectually honest by not admitting that they do not have the legal standing to back their claims.
The reason why I say that this is not a legal issue, therefore, is that, unless and until the WPF sues a theme developer on the issue of whether a theme or plugin that doesn’t incorporate wholesale code from the main project is a derivative work, this is a business issue that can deeply affect the future of WordPress if not handled correctly. Hence my points in the previous article.
One thing that many do not seem to understand that the enforcement of a contract (or a license) is, essentially, a failure of the contract itself. A contract exists so that two parties can have an understanding on how a business relationship should take place. If the contract is sufficiently clear and unequivocal, it should only ever be enforced if one of the parties maliciously and willfully breaches it and then refuses to cure the breach. If it is unclear and equivocal, as is the case here, the enforcement of a contract represents a failure to draft a proper agreement in the first place.
When people play armchair lawyers and give their own interpretation of the legal meaning of the GPL, I can tell immediately that they have never had the unpleasant experience of being involved in a lawsuit. Those who have, on the other hand, know that lawsuits are a very dangerous game whose rules are known only to those in the legal profession—and are, ultimately, in the hands of a referee who is as human as everyone else, and often called upon to render judgment on topics he or she has no real technical expertise to understand, let alone determine. It’s like playing a game of soccer in which losing might mean forfeiting your business, house and livelihood, and in which each team can put as many players on the field as their money allows. Oh, and the refs are asked to rate the player’s bedroom technique instead of counting the goals.
When most people talk about lawsuits and court cases, they think “Law and Order” or (God forbid) “Boston Legal,” and truly have no idea of what they are getting themselves into—the long hours, constant uncertainty, ridiculous expenses and inevitably dangerous outcome. In real life, lawyers don’t stomp around a courtroom yelling “you can’t handle the truth!” They drudge endlessly through point after point, doing whatever they can to help their client prevail, often flying in the face of the very things their client has done or agreed to in the past. It’s their job and, even though while they are doing it you would like for nothing better than jump up from your chair and stab them in the eyeball with a pencil, you can’t fault them for it. Remember, despite the fact that everyone called bullshit on SCO’s claim against Linux vendors, it took seven years to finally kick them to the curb. Is that they way you want to run your business?
Regardless, enforcement is not the point of a contract—the point of a contract is to establish a clear framework in which everybody can conduct their business in a clear and unequivocal manner.
It was a honeypot!
Ultimately, I am happy that so many decided to post “legal” comments to my article. In fact, I was counting on it, because it helps me drive home a simple point: we need a better framework than the GPL to help us define our freedom.
What is happening in the WP world is a perfect example of how the GPL’s one-size-fits-all approach is failing us. If Matt wanted themes and plug-ins to only be distributable under the GPL, he could have simply expressly said so in his license, thus clearing the air once and for all. Of course, this wouldn’t prevent some third party from maliciously attempting to circumvent the license, but then at least we could focus on the maliciousness of their action instead of grasping at straws trying to figure out what the license means in the first place.
Instead, we are stuck with the GPL and its less-than-perfect definition of derivative work and this, at the very least, is going to cause concern and confusion. Remember, even though you may be convinced that a particular interpretation is the correct one, that doesn’t mean that everyone else will as well. I, for one, disagree with Matt’s interpretation of the license and I will freely admit that I would have probably missed this particular problem had it not been brought to my attention by what has happened. Luckily (for me), it doesn’t affect any work that I have done, but it will now force me to think twice about any project that we build based on WP.
By the same token, if this issue becomes big enough, any reasonably sophisticated client that does his homework will have to wonder how the licensing of WordPress—and the WPF’s willingness to go to court in an effort to enforce its own vision thereof—will affect their projects. At the very least, they will want to consult a lawyer on the topic, which is expensive and will probably lead to an inconclusive opinion (which, I believe, would be the only honest one). Again, what you think is the right or wrong way to interpret the GPL means absolutely nothing—what matters is what the client thinks and, if you’re handing out legal advice because they ask you, you’re setting yourself up for big trouble down the road when it turns out that you were wrong.
This is why, in my previous post, I said that no good can possibly come from what has happened. It’s not so much that I dislike the GPL—which I admittedly do; it’s that it needlessly introduces problems that we shouldn’t have to deal with. Contracts and licenses should be the legal expression of a business intent and must, therefore, be written with the business goals of each particular project in mind by lawyers who are acting the best interest of their clients (the project maintainers). The GPL, which is itself not free, is written in the best interest of the FSF to protect a prototypical, but abstract, software product. If you adopt it, you are letting someone else impose their philosophy, values and objectives on your work.
A final thought on copyrights and work for hire
A number of commenters honed in on whether client work is work for hire or not, expressing surprise at the fact that I do not normally assign copyright when I work as a consultant, so I thought I’d spend a few extra words explaining my position on the subject.
When a client engages my services, there are usually two scenarios: either they ask me to solve a specific problem, or they ask me to build something for them. The distinction is, in my mind, very significant. If a client comes to me and asks me to, say, develop an algorithm to do something, I consider that work for hire and am happy to assign all the appropriate rights to them.
When, on the other hand, a client asks me to develop a solution—for example, build a website or perform any work in which the end product is unique to client, but the processes that are used to arrive to it are not—then I insist on maintaining copyright and assigning a properly-drafted license to the client. The reasoning is that my client is not purchasing access to my trade secrets or to the methods and knowledge that go into creating whatever the final product is. Rather, they are employing my knowledge to enable them to perform a particular task. This is not unlike, for example, buying a car: you do not acquire the copyright in its design or the trade secrets that go into, say, the creation of the drivetrain: all you buy is a tool that allows you to move.
In these cases, the final license has, obviously, to be appropriate to what the client needs to do with the product—for example, modify, redistribute, sublicense and so on. But the ownership remains mine, because the knowledge that goes into the product is orthogonal to the product itself. Note that copyright and trade secrets are, obviously, two separate concepts, so that the copyright in code I write could be assigned without having to give up the associated intellectual property, but why confuse the issue? Being able to reuse portions of code between projects makes it possible for me to provide my clients with more affordable services without compromising the uniqueness of their product and gives me the opportunity, if I so choose, to release it as OSS. Naturally, the client maintains control and ownership of all of their bits and pieces, like trademarks, proprietary code that is included in the final product, etc. etc.
There are, of course, some exceptions, but by and large I have yet to encounter a client worth working for who has a problem with this—in fact, it’s great for clients whose internal policies make it difficult for them to interact with OSS, since the copyright never gets assigned to them and the product can, therefore, be directly distributed under an open-source license.
