10

I am developing a piece of software. The software is based on a piece of open source software. My question is how much must be changed / edited before I can call it my own? Also how do you classify how much is changed?

The code I'm building on is BY-NC-ND but if the code is still not technically my own (I did not write it) morally do you think I should provide some credit?

  • 5
    AFAIK As long as your work is based on the work of someone else, it will always be a derived work. Even when you replace 100% of the code, the fact that you gradually evolved it based on the work of someone else means that it still is derived. But I can't find a good source for this ATM. – Philipp Jun 24 '15 at 19:20
  • 4
    To show why this is a derivative work, think about why you are not building from scratch: because it's easier to build on their work, even if you intend to eventually replace it entirely. That is exactly the reason why it is still a derivative work: you work from the base that is provided by the original code. – Martijn Jun 24 '15 at 19:30
9

The code you're building on in BY-NC-ND, which requires attribution, forbids commercial use, and disallowed derivatives.

If you build on that code, it's a derivative, which is not allowed by the license. Even if you gradually replace everything, it is still a derivative.

Anything you change you can call your own, but the resulting work will always be a combined work of the original work and your changes, even if none of the original code remains.

  • 1
    Thanks, I'm not far into the project so I may just restart. – Trevor Clarke Jun 24 '15 at 19:31
  • Actually, if you replace everything, the result is no longer a derivative. Historical example: ATT Unix to BSD. But it can be quite difficult to prove that all of the original bits are gone and not just transformed. – Gilles Jun 25 '15 at 0:39
  • @Gilles what you're saying seems to contradict the accepted answer here. Perhaps you meant to clarify that the replacement process must be a clean-room implementation? – congusbongus Jun 25 '15 at 9:20
  • @congusbongus There's no contradiction. The replacement process does not have to be a clean-room implementation. However, if it isn't, it's hard to defend against charges of copyright infringement. If the project history shows that B the result of modifying A, this creates a presumption that B is a derivative of A. Even if B was implemented by looking at A and not reusing it directly, this sets a presumption in the wrong direction. Making sure that B was written without looking at A reverses the presumption: A would have to find some evidence of infringement. – Gilles Jun 25 '15 at 10:11
  • @congusbongus The test is "was any copyright infringed," not "how did you do the rewrite?" Clean-room implementation is just a tool to make it easier to prove no copyright infringement exists; the critical effect is that there is a written record of everything which was carried over from one work to the next work, which (hopefully) you can argue contains nothing that is copyrightable as a matter of law. But you can establish that nothing copyrightable was copied over without that; it's just much harder. – cpast Jul 8 '15 at 5:54

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.