Open Source, Copyright and Trivial Bugfixes

Question

Say a developer has developed a library for their closed-sourced commercial application. Since they want to give back to the open source community, they publish this library under, say, the GPL, but continue to use it in their own application. Since they hold the copyright, that's fine.

Now, a user of the GPL version finds a bug, fixes it and submits a patch to the original developer. As I understand it, to use this bugfix in their closed-source application, the developer needs to have permission from the submitter. If the submitter refuses, the developer has to find another way to fix the bug in the closed-source version.

But what if the bugfix itself is really trivial? Like properly initializing a variable or checking for a null pointer? Something that any half-competent programmer can find and fix in a matter of minutes, given an error description? Is the patch for this still protected by copyright? Or can the original developer implement the identical fix in their closed-source application without consent of the submitter?

Note: This really is a hypothetical scenario, not one of those "my 'friend' has this problem" questions

Answer 1

Caveat: I am not a lawyer!

Updated: Trivial bugfixes are likely not subject to copyright. See Michael Shaw's answer, which I believe to be more accurate than what I originally said, for more information.

However, even given that, this situation is less than ideal:

• This may be fairly clear for your contrived example, which posits a change that is trivial, as opposed to adding significant functionality. However, in real life it is going to be a judgment call as to when that is the case. You will be left in a copyright gray area.
• Ideally, you want to just incorporate the updated file in your program; you don't want to add your own code, even if it is trivial. It just duplicates work unnecessarily.
• Now there will be two versions of the file: yours and the open-source one. This just makes a mess if you want to later release updated versions of your code to the community.

Conclusion: The Gnu Public License specifically restricts use of the code in closed-source programs. Thus, releasing your code under the GPL amounts to deliberately creating a fork of your code that can't be incorporated back into the original program. This doesn't make a lot of sense.

You would be better served by releasing your code under a more permissive license, such as one of the BSD licenses or the Artistic License. These licenses allow the code to be included in closed-source software without additional permission. Usually any further development by the community will occur under the same license you used, so you will be able to incorporate any changes that are made (minor or significant) into your software.

Technically, someone could decide to update your code and then release it under the GPL, but they would have to actively make that choice. It wouldn't be the default position. And in doing so, they would be cutting off their release from any updates you make, so it probably wouldn't be beneficial for them (given that it is your software, you will likely be doing more development on it than anyone else).

Answer 2

If the bugfix is really trivial, then it likely isn't copyrightable at all, especially if there really isn't any other way to write the code. There are hundreds of millions of ways of writing a love poem or a video game, there really aren't more than one or two ways to write if (*p == NULL). Copyright is on the expression of an idea, so if there isn't really any choice in how an idea is expressed, there can't be a copyright.

However, if the bugfix is still fairly trivial, there could be a few dozen ways of expressing it, so it could be copyrightable. And it might not be easy to tell whether something that's fairly trivial is barely copyrightable or barely uncopyrightable.

It is also possible that it might be copyrightable, but that using it would be fair use. Fair use is a bit complicated, since it depends on weighing several factors, and it might not be helpful, since whether fair use applies would be decided by a court -- ideally, you don't want there to be a court case at all, however strong your case might be. One of the factors of fair use is the fraction of the work that was used (this is against you, since you took the whole thing), and another is the commercial potential of the work (this is for you, since the commercial value of a trivial bugfix by itself is zero), so guessing which way a court might rule is error-prone.

Probably the best way to deal with this is to hand an exact description of the bug and its exact location to a developer who hasn't seen the patch. They can then independently fix the bug (which will take very little time, since this bug is trivial), and all of the potential copyright problems disappear, since if it is copyrightable, you own the copyright. Your developer may end up with nearly exactly the same code as the patch because there is essentially only one way to write it, but in this case it isn't copyrightable.

Answer 3

My inexpert opinion, after reading http://www.ifosslr.org/ifosslr/article/view/30/64, is this:

The original work has a sole authorship and that person owns the copyright and may choose to license the work how they wish and indeed has.

Now a developer finds a bug and contributes a fix. This could be regarded as not copyrightable (too small a contribution) but say it was a substantial contribution. The original author accepts the contribution thereby making the work a collective work, since both individuals have agreed to the merging.

In a collective work each author owns their respective parts but each also owns an undivided interest in the whole work and as such each may release the whole work under any terms they wish.

If this is a reasonable interpretation then the controversy isn't whether or not the original author can use the bug fix in their commercial release, which IMO they can. The potential conflict is whether the bug fixer believes they have their own undivided ownership in the work as a whole. In which case it may be advisable for the original author to obtain a release from the bug fixer that clearly indicates they accept no ownership in the work.