[License-discuss] exploring the attachment between the author and the code
Nicholas Matthew Neft Weinstock
nweinsto at qti.qualcomm.com
Fri Feb 28 18:55:11 UTC 2020
** Although I am a practicing attorney, this should not be viewed as legal advice. I am only providing my own thoughts on the subject for the purpose of participating in discussion of a topic that I find interesting. Also, note that the law is much deeper than the points I'm touching upon here. Seek your own legal counsel to be safe. **
You touch on a few excellent and interesting topics that have both emotional and legal implications. I want to address some of the legal ones.
You distinguish between the idea and the expression of the idea.
The quadratic formula is the idea. ax^2 + bx + c = 0. The three different implementations are distinct expressions of the idea.
Copyright law is focused on creative expression. In software, if there is any creative expression, it would be in the implementation of the idea.
However, this brings up a second topic you (indirectly) touch upon. Copyright only protects creative expression, it does not protect things that are purely functional.
Is implementation of this idea creative, or is it purely functional?
For a while, courts looked for functionality. They reasoned that if it's functional, it can't be creative.
More recently, and especially with software, they flip the question around. Is there any creativity, something that would distinguish one implementation from another based on particular choices?
The two examples you referenced are very different implementations of the same idea. Different programming languages, one uses C++ Classes. Different ways of organizing the data, different variable types, different error checking. This suggests that there is creative expression in each implementation. So each implementation would be Copyrightable.
Next, you suggest that you would create your own implementation. This has the potential to get quite tricky.
If you only look at the bare formula and write your implementation, it's clear that you created the implementation, you are the owner. You can distribute it under whatever license you want.
BUT, what if you had looked at implementation A before writing yours?
If you copied some creative elements of implementation A, you are creating a derivative work. You need a valid license for implementation A that allows you to create a derivative work. Then you would own the copyright in whatever additional creative elements you added, but not the underlying part you took from implementation A. And since implementation A is under GPLv3, your license to create and distribute derivative works is conditioned on your distributing the resulting work under GPLv3. If you distribute under a different license, you lose your license to A.
Finally, getting to the question about subsequent modifications. This combines the previous topics.
If the subsequent modifications have their own creative expression, they would be independently copyrightable by whomever created those modifications. As maintainer, you would be responsible to make sure that the contribution is compatible with your license. This is where things like DCO or CLAs can help maintainers, to provide some assurance regarding the origin and rights to the contribution they are receiving.
With small changes, that's not always very clear. If someone is fixing a typo, is that creative expression? What if they are changing variable types for purely functional reasons (e.g., int to long)? What about changing variable names to facilitate readability? What about beautification, such as normalizing indentations? What about adding comments to explain a function?
With larger changes, it can be easier to see the creative expression in these modifications. Think about adding entirely new files, or rearranging an implementation to add functions instead of being purely inline.
So to me, something like the "grandfather's axe" question becomes very interesting. Even if every line of code that you wrote eventually gets replaced, is it possible that the creative expression in your initial implementation could still be lingering in the structure, sequencing, or organization of the implementation? Or, conversely, is it possible that the implementation still has your code, but it has been so spliced and reformatted and polished that the subsequent contributions have effectively replaced all of your creative expression?
One last point: I'm only talking about Copyrights. I'm not touching on Patents because mathematical formulae aren't patentable, so it's not relevant to this question.
From: License-discuss <license-discuss-bounces at lists.opensource.org> On Behalf Of Gil Yehuda via License-discuss
Sent: Friday, February 28, 2020 8:16 AM
To: Gil Yehuda via License-discuss <license-discuss at lists.opensource.org>
Cc: Gil Yehuda <gyehuda at verizonmedia.com>
Subject: [License-discuss] exploring the attachment between the author and the code
I'm exploring the psychological relationship between the author of a work, and the work. i.e. parsing the phrase "my open source code" and would like your thoughts.
Assume I need an algorithm, say the quadratic formula. https://github.com/spilos/Equasion-Solver is promising and is licensed under GPLv3. https://github.com/jasonwynn10/Past-Console-Projects/tree/master/quadratic%20equasion is also promising, and is released to the public domain under the Unlicense. Option C: I write my own code and publish it under a license of my choice.
Obvious differences (language, licenses, amount of work involved in incorporating it into my larger solution) are apparent. Less obvious to everyone but me is that Option C is "my" code, and I feel an attachment to it. When I license it, I'm declaring terms on how I want you to use 'my' code. Thus I'm exploring the idea of "my code" with this group, since it informs my license choice.
1. When I use open source code in my solution, I still feel that my solution is mine (even though others wrote some of it).
2. When my code is used by others, I don't feel less attached to my code. It still feels mine.
3. When an open source community modifies my code, when is it no longer my code (grandfather's ax problem)?
You see, I realize the quadratic formula is not mine. My coding is mine, but I'm just encoding someone else's solution, a solution discovered hundreds of years ago. I'm encoding it in a syntax someone else specified. My solution may be novel to me, but not to others. So what is it that attaches me to code such that I decide the terms under which you use it in your solution?
Gil Yehuda: I help with external technology engagement
From the https://developer.yahoo.com/opensource/docs/ at Yahoo --> Oath - -> Verizon Media
More information about the License-discuss