Our recent announcement at EECI 2011 of adopting a new license for CodeIgniter has sparked a flurry of conversations and debates. We anticipated that it would, and are glad that it has gotten so much attention from developers and the community as a whole. Our initial plan following EECI was that of simply trying to communicate and explain our reasons behind choosing a new license and how we think it will benefit the community. Because of the attention it has received, we’ve decided to go in another direction to help educate and enrich the community.
So in its place, we are devoting a week’s worth of blog entries here at EllisLab.com to software licensing. We thought this would be especially helpful to our community of add-on developers since we have heard of many of your struggles in figuring out how to best license your software.
Each day a new topic related to software licensing will be commented on, sharing our perspective, and hopefully generating meaningful conversation among developers inside and outside of our community. Most people don’t put a lot of thought into licensing, whether accepting the terms of a license granted to them, or in choosing and carefully applying a license to their own work. And licenses can be confusing and easily misinterpreted.
But the reality is that developers are called upon daily to make decisions about using others’ software and licensing their own, yet software licenses were not made with the common developer in mind. They are the purview of copyright lawyers and legal teams. Most of you don’t work in firms that employ such a team nor perhaps do you feel that you have the money or desire to hire one. But these are legally binding agreements or contracts, so consulting an attorney is a basic requirement. As such, you will find plentiful disclaimers like the one below in this series of posts:
The content in this article is neither legal advice nor a legally binding interpretation of the licenses discussed, including those distributed with EllisLab products. We are sharing our opinions, thoughts and conclusions which we hope are helpful and spark meaningful discussion. You should consult an attorney with questions regarding your specific legal needs and the terms or interpretation of any software license.
This first post covers some basic conclusions about software licenses that when misunderstood, lead to speculation and FUD for any license or use of code. After discussing a few of these basic points, we’ll outline the topics coming later in the week.
If a software license is ever brought into question, it will be a judge or ruling copyright authority in the location you reside (or the one bound to the license agreement) that will interpret and render a judgement, not the copyright holder or author of the license.
This is profound. This means that regardless of the intent, even EllisLab could not interpret its proprietary, simple license used for CodeIgniter. Well, we could, but in the end, it’s a judge that would decide how it applied. This basic conclusion extends to the Open Source Initiative (OSI) and the Free Software Foundation (FSF). The FSF can make statements about the GPL, for instance, and they may be called as witnesses if a lawsuit ever came about dealing with GPL code. But they cannot form the legal basis for the application of the license. A license author is bound by the legal verbiage they chose to use when creating the software license.
So while a license my be written with a particular intent to allow or disallow X, Y, or Z, the intent rarely matters, rather the interpretation of the wording of the license as it compares to local and international copyright law by the ruling authority (commonly a judge).
Software license agreements can grant additional rights to a licensee beyond what copyright law allows, but the copyright holder still owns the work, and retains a right to license it how they choose.
The author, you, always has whatever rights are granted to you (or protected, depending on your point of view) by copyright law. While there are no “take-backs” to the application and release of your work with a liberal license, you still own the original work. Unless you have legally transferred copyright to a third party (which some licenses may do!), nothing would prevent you from doing what you like with your own work, including modifying it and keeping the modifications your own, or providing a different license for a different purpose.
In the software world, that means that once applied to code, licensees benefit from whatever grants you have given them in receiving that specific work under that license. You do not need to license your own copyrighted works to yourself.
Which brings us to another conclusion:
Code should contain a clear notification of the license it is distributed under. In absence of such a notification, code comes with no additional grants beyond that given by copyright law.
This sounds obvious once read, but particularly in the PHP community, developers are extremely negligent in this regard. Simply putting on your website that a download is licensed as Foo does not necessarily extend the rights granted in Foo to people who download that software. The license and notice should be in the code itself, otherwise there is no means to prove under what license a person received the software.
This is why you will find in EllisLab products a license notification in each file. In fact, many common licenses include this as an obligation of the Licensor.
Here’s the last conclusion we’ll leave you with in today’s post:
When dealing with free software communities, it is extremely rare that anyone would ever want to sue another party over licensing, much less go through the trouble, time, and expense of filing such a lawsuit.
Typical software license lawsuits occur in commercial software involving patents, trademarks, and the like. In the case of free open-source products, the likely sources of lawsuits would be people or entities claiming prior copyright or patent on works that are included in it. That would be the case regardless of what license the open-source product was using.
Incidentally, this is one of the many reasons we chose the Open Software License v3.0 (OSL 3.0), because at least such a lawsuit would come at a cost: termination of the rights granted by the license in the first place. You can’t take away someone’s right to sue you, but such a clause (§10 of OSL 3.0) at least takes away their right to use the product the moment they initiate a patent lawsuit. If they’re using and benefiting from the product, that’s typically a good deterrent to a lawsuit, encouraging trying to solve any problems they have without litigation.
For the rest of us in the free open source world - who wants to sue? Certainly we don’t. For us it’s about respect.
Respect for your own work and the work of others.
Respect for the individual or company using your product and making a living with it.
Respect for the individual or company who freely gave you the tools you use to make a living.
All in all, we hope this series generates a larger awareness of software licensing issues and answers as best we can the questions that people have of EllisLab’s decisions regarding licensing. But we also hope it impresses on every developer the importance of due diligence in license research, which includes consulting an attorney. Whether free or commercial, make sure that the license you choose respects you and your own work, as well as those who end up using your software. Don’t turn licensing into a casual decision, or you are doing yourself and your users a great disservice.
Here is what’s coming up later in the week:
Friday we are leaving flexible in case discussion raises interesting topics that we haven’t planned for. If nothing specific catches our attention, we will end Software License Awareness Week with an overview of the process we used for settling on OSL 3.0 for CodeIgniter, and attempt to answer any remaining questions encountered in the forums, Twitter, Uservoice, etc.
Software License Awareness Week onward!