How to change the code so that it does not fall under the violation of the license &quot;partial copying&quot; Good afternoon! I'm interested in a legal issue regarding code licensing. I am writing an Ansible role for two companies, and each company wants to impose its own license on this code: “full or PARTIAL copying is prohibited”. The point is that I am writing a role for the same environments and services. Naturally, it turns out that the roles are very similar. And since the changes in the code can not be swung in the role of Ansible, no matter how you say it, it will be at least recognizable. For example: - name: "Oracle | Install basic Oracle 7 repos" yum_repository: name: "{{ item.name }}" description: "{{ item.description | default ('No descr') }}" baseurl: "{{ item.baseurl }}" gpgcheck: "{{ item.gpgcheck | default ('0') }}" gpgkey: "{{ item.gpgkey | default ('file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5') }}" state: "{{ item.state | default('present') }}" enabled: "{{ item.enabled | default('yes') }}" priority: " {{ item.priority | default('20') }}" with_items: "{{ linux_oracle_yum_repo }}" tags: - update In both companies, this piece of code is similar to one and it does not work out to change much. I ask for a little help in the legal issue of this situation: HOW much do I need to change the code so that it does not regarded as "partial copying"? Is this changing a one character in a file? Or in the whole program? Or changing one line? Or need to dial a certain percentage of the code difference? Or is it enough just to change a name the variables and the descriptions? Thank you for help!
If you change a single character, that's clearly a partial copy. Copyright protection has a limited extent, however. The protected work must be original and not obvious. For example, there are only so many ways to write a function that computes the average of two numbers, so the copyright owner of one body of code cannot claim infringement by the author of a second body of code simply because they both have a function float Average(float a, float b) { return (a + b) / 2; } A surefire way to avoid infringing copyright is to specify the function of the code and then have someone who has never seen the code write it from scratch. This is sometimes called clean-room engineering. Otherwise, there is no way to answer your question definitively. If you create a modified copy of the code (a "derived work" in copyright terminology), there is no strict formula available to evaluate the extent of the infringement. It comes down to a case-specific analysis of the facts by a judge. Depending on the jurisdiction, which you have not specified, there may be specific laws or judicial precedent that guide the judge, but the determination will still require a specific analysis of the facts. For example, if the alleged infringer raises these arguments, the judge would have to determine how obvious the code is, or whether the copyright claimant even owns the copyright to the code.
Yes you can. What you do is called mere aggregation. Your app and the GPL container run isolated and do not share memory space: they are clearly separate programs vs parts of one program, so your app does not get infected by GPL.
There is no contract between you (the licensee) and the licensor of the software. The creator of the open source software just says "here's the software, you may use it if you like, as long as you fulfil some conditions. ". No contract, no liability. I think the developer would only be liable if they intentionally created software that causes damage. (Which has happened, some open source browser plugins have recently been modified to run bitcoin mining software, or worse. I suppose the miscreants could follow all the GPL rules or whatever license is used).
The MIT license is non-exclusive. If S is the sole copyright holder, S can issue any other non-exclusive license in parallel, and can also stop offering the software under the MIT license. However, open source licenses such the MIT license are generally understood to be irrevocable, so S cannot prevent other people from using the software who already received it under the MIT license terms. But: only if S is the sole copyright holder. There is no particular reason to believe that S would be the sole copyright holder. One does not gain a copyright ownership just by supervising other people, although an employer might gain copyright ownership over works created by employees (e.g. the US “work for hire” doctrine). That the copyright notices only mention S's name is an indication that S might be a copyright holder, but that's neither sufficient nor necessary for showing that S holds sole or joint copyright in the software. This leaves three relevant scenarios: S might be the sole copyright holder, in which case, yes, S can effectively discard the MIT license. This might be the case e.g. if there was some other copyright assignment, outside of the MIT license. What copyright transfers or assignments are valid depends on the local laws, e.g. some jurisdiction do not recognize copyright as transferable and at most allow the assignment of economic aspects of copyright. S might not be the sole copyright holder, but have additional permissions to the work. For example, there might have been extra licensing agreements, outside of the MIT license. Or S might have special rights for a work of joint authorship, if and only if the jurisdiction recognizes such additional rights. S might not be the sole copyright holder and not have any agreements outside of the MIT license. Then S has no additional rights, and is bound by the terms of the MIT license. This doesn't have to be a problem: S can still pretty much do whatever S wants with the code, as long as S fulfils the license terms. These are pretty simple: just keep a copy of the copyright+license notice with any copies of the software the students created.
The GPL that covers the OpenJDK certainly allows you to write and distribute your own Java implementation. On that point, your reading is absolutely correct. However, if that implementation is a derivative work of the OpenJDK, then the GPL requires you to make your derivative implementation available under the GPL as well, per the GPL's copyleft rules. If you follow the rules of the GPL, you can do exactly what you propose. Note that the Supreme Court ruling in Oracle v. Google found that using only API structure and names, without copying any underlying implementation, constitutes fair use, and therefore doesn't require copyright permission. If you hold your implementation to that standard and use/look at only interfaces while authoring your new implementation, then your new work is broadly allowed under copyright law, so you do not need to rely on the GPL's permissions (and therefore neither do you need to follow its requirements). Google didn't want to have to abide by the terms of the GPL, probably because due to concerns that the any GPL terms that applied to their Java implementation might also apply to other components of their system, which they wished to keep closed-source. In other words, if Google had claimed their acquired their right to use the APIs under the GPL, then they would have been required to put potentially the entire operating system under the GPL, which they had not done nor wished to do. For this case, the GPL has been largely ignored because Google has not followed the requirements of GPL in licensing their Java implementation (and operating system that uses it), so there's no point in Google trying to claim that their right to use the API came from the GPL. Furthermore, Google claimed that they didn't use any of Oracle's copyrighted material, so it's not possible for them to say their use of Oracle's material was licensed under the GPL, as they claim there was no use whatsoever, licensed or otherwise. This is explained at length on fosspatents.com's article &quot;Q&amp;A on the Dec. 4 Oracle v. Google Android-Java copyright hearing before the Federal Circuit&quot;: 2. Q: Does this litigation involve Google's rights to use certain Java code under an open source license? A: No. Google could have incorporated Java into Android on open source terms, but chose to eschew the GNU General Public License (GPL) because of its &quot;copyleft&quot; feature. [...] If Google had ever claimed in this litigation that Android's incorporation of Java was authorized under the GPL, this would have been inconsistent with its claim that it didn't use any copyrightable material (you can only license something, on whatever terms, if it's protected) and, far more importantly, a blatant violation of Rule 11 (truthful pleading standard) resulting in sanctions for Google and its counsel. The GPL affords you four freedoms: it allows you to use software without paying for it (freedom 0), to modify its source code as you please (freedom 1), to redistribute copies (freedom 2), and to distribute your modified versions to others (freedom 3). But once you exercise freedom 3, you're subjected to the copyleft rule: you must make your modified version available under the GPL. As a result, Google would have had to publish Android under the GPL. But it did not. [...] [...]Google seeks to exercise as much control over Android as possible. If Android had to be released under the GPL (and only under the GPL, or at least a compatible copyleft license), Google would have a hard time keeping a growing number of core Android components like its Mail and Map clients or even the new on-screen keyboard (again, more about that in the next section) closed -- and Google's hardware partners would have to release their proprietary enhancements such as Samsung's Touchwiz and HTC Sense under the GPL, which would run counter to their objective of differentiation because their competitors could then use the same code.
Ideas (methods of playing, game mechanics, strategy, goals) cannot be protected by copyright. But any part of a creative work can. So, no copying of drawings, patterns, images, sounds, or the element. I suppose copying the software code is not an issue here, but it can, obviously, also not be copied. And nothing in your game can look like someone's else trademark.
My opinion is that the copying of a single API endpoint, "run" that takes a function as an argument is not infringement. I can think of several lines of argument that get to this same conclusion: Originality: It doesn't exhibit the modicum of creativity required by the originality test. (Feist) Short phrases doctrine: It is a short word or phrase, which both the copyright office (Copyright Office Circular, 37 CFR 202.1) and courts (e.g. Hutchins v. Zoll) have declared ineligible for copyright. Merger: The merger doctrine allows reuse of an expression if it is one of only a very few number of ways of expressing an idea. I can't think of many other ways to express a function intended to run a function other than with the verb "run". Scènes à faire: It is not infringement to use an expression if it has become standard, stock, or common in a particular setting. Naming a function "run" is common in the programming community. Any one of these alone would be enough to rule out copyright infringement by taking this individual component of Excel's API. Note: Whether merger and scènes à faire are part of the originality/copyrightability analysis or part of the infringement analysis is not uniform across circuits. For example, the 6th circuit considers both merger and scènes à faire part of the copyrightability analysis. But, the 2nd and 9th circuits treat them as part of the infringement analysis and in the 9th circuit, they are affirmative defenses.
The code and the “look” of the user interface is protected by copyright - you can’t duplicate either. You can create your own app with the same functionality.