5 ms·

> All in all it took us under a week to secure the assignments, and any who did not sign we simply rewrote their lines of code, or we would have, but everybody

by simias 6y ago

> All in all it took us under a week to secure the assignments, and any who did not sign we simply rewrote their lines of code, or we would have, but everybody signed. I've always heard about this possibility but I wonder how one would rewrite code, should the need arise. Wouldn't it be hard to do without effectively making a derivative work? Suppose that you remove the code, reimplement it but end up with something that's extremely similar to the original (which is very likely since after all you're doing the same thing). Couldn't the original author argue that it's still their code? How do you prove that you did the work and just happened with the same code because that's just the most straightforward way to do it? It seems like the only way to avoid the problem altogether would be to have some sort of clean room design: - Dev A reads the code to be removed, writes a spec for the functionality. - Dev A removes the code. - Dev B takes the truncated code and the spec and implements the feature. But that seems very painful to do cleanly, in particular one could argue that B should be a third party who is not intimately familiar with the codebase, otherwise it could be argued that they knew the previous code.

girst 6y ago
The plan you've described is exactly what https://jshint.com/relicensing-2020/ https://jshint.com/relicensing-2020/ did. ETA: discussed here, with a more in-depth link: https://news.ycombinator.com/item?id=24051655 https://news.ycombinator.com/item?id=24051655
- julianlam 6y ago
  Thanks! We did this with guidance from a lawyer, but didn't check to see how other projects handled it. I'm glad to see we followed the lead of other similar projects.
peteradio 6y ago
There is no Dev A and Dev B, just Dev 1 renaming the variables so none of the words are the same LOL. Could probably make a plugin for IDEs to do this automatically called "uncopywrite" or "breaklicense" which does it automatically. Maybe it already exists? I kid... but doesn't it all seem a bit ... stupid?
- kadoban 6y ago
  I think you're aware, but yeah that does basically nothing. It certainly doesn't break the copyright.
  - ramshorns 6y ago
    It breaks it in the sense that it violates the license.
julianlam 6y ago
We debated internally about what this would look like, and in the end we decided that should the need arise, the process would be: 1. A commit to plainly remove the functionality (or lines of code) 2. A developer would rewrite the code with a set of variables they cannot use, but I suppose they'd also code without the original implementation as reference. Each individual developer's implementation should be different enough that it would be easy to tell that it was independent crafted, although something like this hasn't been tested in court (at least to my knowledge!)
- not2b 6y ago
  The way this is sometimes done in industry, when the copyright owner is known to be litigious, is for developer A to read the code and write a spec. Developer B writes the new implementation based on the spec. If B has any questions, she cannot take to A directly, the questions are routed through a lawyer to make sure that nothing copyrighted is exchanged. (that last part might be overkill, but if the other party is Oracle you might want to use it). If the developer who does the rewrite uses the original as a reference, it will be likely that enough of the structure will creep through that the project will be at legal risk.
- Wowfunhappy 6y ago
  Something that always gives me pause: what would happen if a developer removed a bunch of code? That can of course take a significant amount of time/energy/skill in itself, and is presumably copyrightable work. But, how could it possibly be re-done?
  - ignoranceprior 6y ago
    This is an interesting question. I'm certainly not a lawyer, but it's not obvious to me whether or not removals of code would be copyrightable. If Dev A writes 1000 lines of code, and Dev B carefully removes 20 specific lines that are unnecessary or introduce bugs, the resulting codebase consists entirely of Dev A's code, but Dev B might justifiably claim to deserve credit for their effort. I'd like someone more familiar with copyright law to chime in.
nabla9 6y ago
Yes. https://linuxinsider.com/story/clean-room-development-avoids-copyright-battles-33839.html https://linuxinsider.com/story/clean-room-development-avoids...
inopinatus 6y ago
> How do you prove that you did the work and just happened with the same code because that's just the most straightforward way to do it? This was a factor in Intel's case with NEC over the microcode of their 8086 clone, and the judge ruled in NEC's favour, finding that similarities dictated by functional constraints were (subjectively) not creative expressions i.e. copyright did not apply.⁽¹⁾ Note this relates to copyright, does not extinguish patents, and actually relying on this precedent may require bottomless legal resources. ⁽¹⁾ NEC v. Intel: Breaking New Ground in the Law of Copyright. Contreras, Handley, & Yang; Harvard Journal of Law & Technology vol. 3, page 213 (1990). http://jolt.law.harvard.edu/articles/pdf/v03/03HarvJLTech209.pdf http://jolt.law.harvard.edu/articles/pdf/v03/03HarvJLTech209...
boogies 6y ago
> I've always heard about this possibility but I wonder how one would rewrite code, should the need arise. Wouldn't it be hard to do without effectively making a derivative work? This is an issue GNU has faced, they recommend optimizing for different things: > If you have a vague recollection of the internals of a Unix program, this does not absolutely mean you can’t write an imitation of it, but do try to organize the imitation internally along different lines, because this is likely to make the details of the Unix version irrelevant and dissimilar to your results. > For example, Unix utilities were generally optimized to minimize memory use; if you go for speed instead, your program will be very different. You could keep the entire input file in memory and scan it there instead of using stdio. Use a smarter algorithm discovered more recently than the Unix program. Eliminate use of temporary files. Do it in one pass instead of two (we did this in the assembler). — https://www.gnu.org/prep/standards/standards.html#Reading-Non_002dFree-Code https://www.gnu.org/prep/standards/standards.html#Reading-No... In fact RMS had experience from his competition with Symbolics: http://www.gnu.org/gnu/rms-lisp.en.html#foot-6 http://www.gnu.org/gnu/rms-lisp.en.html#foot-6 > The Symbolics source code was available at MIT, where I was entitled to read it, and at first that's how I found out about their changes. > But that meant I had to make a special effort to solve each problem differently, in order to avoid copying Symbolics code. After a while, I concluded it was better not to even look. That way I could write code in whatever way was best, without concern for what might be in Symbolics' code. (of course, this applies more to larger utilities, inopinatus’ comment https://news.ycombinator.com/item?id=24955918 https://news.ycombinator.com/item?id=24955918 should come in handy for smaller code snippets)

by simias 6y ago

girst 6y ago

The plan you've described is exactly what https://jshint.com/relicensing-2020/ https://jshint.com/relicensing-2020/ did. ETA: discussed here, with a more in-depth link: https://news.ycombinator.com/item?id=24051655 https://news.ycombinator.com/item?id=24051655

julianlam 6y ago
Thanks! We did this with guidance from a lawyer, but didn't check to see how other projects handled it. I'm glad to see we followed the lead of other similar projects.

peteradio 6y ago

There is no Dev A and Dev B, just Dev 1 renaming the variables so none of the words are the same LOL. Could probably make a plugin for IDEs to do this automatically called "uncopywrite" or "breaklicense" which does it automatically. Maybe it already exists? I kid... but doesn't it all seem a bit ... stupid?

kadoban 6y ago
I think you're aware, but yeah that does basically nothing. It certainly doesn't break the copyright.
- ramshorns 6y ago
  It breaks it in the sense that it violates the license.

julianlam 6y ago

We debated internally about what this would look like, and in the end we decided that should the need arise, the process would be: 1. A commit to plainly remove the functionality (or lines of code) 2. A developer would rewrite the code with a set of variables they cannot use, but I suppose they'd also code without the original implementation as reference. Each individual developer's implementation should be different enough that it would be easy to tell that it was independent crafted, although something like this hasn't been tested in court (at least to my knowledge!)

not2b 6y ago
The way this is sometimes done in industry, when the copyright owner is known to be litigious, is for developer A to read the code and write a spec. Developer B writes the new implementation based on the spec. If B has any questions, she cannot take to A directly, the questions are routed through a lawyer to make sure that nothing copyrighted is exchanged. (that last part might be overkill, but if the other party is Oracle you might want to use it). If the developer who does the rewrite uses the original as a reference, it will be likely that enough of the structure will creep through that the project will be at legal risk.
Wowfunhappy 6y ago
Something that always gives me pause: what would happen if a developer removed a bunch of code? That can of course take a significant amount of time/energy/skill in itself, and is presumably copyrightable work. But, how could it possibly be re-done?
- ignoranceprior 6y ago
  This is an interesting question. I'm certainly not a lawyer, but it's not obvious to me whether or not removals of code would be copyrightable. If Dev A writes 1000 lines of code, and Dev B carefully removes 20 specific lines that are unnecessary or introduce bugs, the resulting codebase consists entirely of Dev A's code, but Dev B might justifiably claim to deserve credit for their effort. I'd like someone more familiar with copyright law to chime in.

nabla9 6y ago

Yes. https://linuxinsider.com/story/clean-room-development-avoids-copyright-battles-33839.html https://linuxinsider.com/story/clean-room-development-avoids...

inopinatus 6y ago

> How do you prove that you did the work and just happened with the same code because that's just the most straightforward way to do it? This was a factor in Intel's case with NEC over the microcode of their 8086 clone, and the judge ruled in NEC's favour, finding that similarities dictated by functional constraints were (subjectively) not creative expressions i.e. copyright did not apply.⁽¹⁾ Note this relates to copyright, does not extinguish patents, and actually relying on this precedent may require bottomless legal resources. ⁽¹⁾ NEC v. Intel: Breaking New Ground in the Law of Copyright. Contreras, Handley, & Yang; Harvard Journal of Law & Technology vol. 3, page 213 (1990). http://jolt.law.harvard.edu/articles/pdf/v03/03HarvJLTech209.pdf http://jolt.law.harvard.edu/articles/pdf/v03/03HarvJLTech209...

boogies 6y ago

> I've always heard about this possibility but I wonder how one would rewrite code, should the need arise. Wouldn't it be hard to do without effectively making a derivative work? This is an issue GNU has faced, they recommend optimizing for different things: > If you have a vague recollection of the internals of a Unix program, this does not absolutely mean you can’t write an imitation of it, but do try to organize the imitation internally along different lines, because this is likely to make the details of the Unix version irrelevant and dissimilar to your results. > For example, Unix utilities were generally optimized to minimize memory use; if you go for speed instead, your program will be very different. You could keep the entire input file in memory and scan it there instead of using stdio. Use a smarter algorithm discovered more recently than the Unix program. Eliminate use of temporary files. Do it in one pass instead of two (we did this in the assembler). — https://www.gnu.org/prep/standards/standards.html#Reading-Non_002dFree-Code https://www.gnu.org/prep/standards/standards.html#Reading-No... In fact RMS had experience from his competition with Symbolics: http://www.gnu.org/gnu/rms-lisp.en.html#foot-6 http://www.gnu.org/gnu/rms-lisp.en.html#foot-6 > The Symbolics source code was available at MIT, where I was entitled to read it, and at first that's how I found out about their changes. > But that meant I had to make a special effort to solve each problem differently, in order to avoid copying Symbolics code. After a while, I concluded it was better not to even look. That way I could write code in whatever way was best, without concern for what might be in Symbolics' code. (of course, this applies more to larger utilities, inopinatus’ comment https://news.ycombinator.com/item?id=24955918 https://news.ycombinator.com/item?id=24955918 should come in handy for smaller code snippets)