On Tue, Feb 20, 2018 at 07:07:26PM +0000, Niall Douglas via Boost wrote:
Let me repeat: the only reason that my use of SO code snippets was noticed is because I added a comment linking back to the original.
Current generation software designed to find copyright and IP code infringement in source code do not need the author to put notices in the source code. They can even find instances of infringement where the author deliberately acted to obscure the infringement, by, for example, changing variables or hiding critical code in small functions or macros or etc.
I am more familiar with this than most. You can rewrite code into a different programming language and it may still infringe. Simply rewriting a routine will not make infringement magically disappear, despite most programmers thinking this to be the case that if it isn't exactly the same, it's not infringing.
But in any case all this is moot. No copyright is being infringed in any case due to the AFC test, which for the record I applied before choosing to reuse this snippet, as I do for all snippets I reuse from StackOverflow. This eliminates problems with IP ownership, which is why I do it.
I am not incompetent at my job or as a software engineer. I do not make choices on IP in ignorance or laziness. Unlike most engineers, I actively read case law as a hobby. In a different life I would have entered law. I know what I am talking about, and I would have wished to have been trusted on my opinion on this.
But okay, let's take the long road on this, as my expert opinion clearly carries zero weight here.
You obviously didn't act to obscure anything. But Dominique has said such software has flagged the code. Enough said. The rational path is to just rewrite the code and move on. Honest mistakes happen in code all the time.
No, he said that his legal team flagged it. And that's because it has a source attributing comment. Had I not commented on its source, nothing would have been flagged by his legal team. Like all the other stackoverflow reuse, it would have slipped by without comment.
Hi Niall, This is what he said: <quote> The company I work for did a Third Party dependency scan of all our code. It was done by a company specialized in code check and the report was analyzed by a lawyer office specialized in copyright, licences, IP... </quote> My interpretation is that the third party dependency scan flagged the code. Then, the lawyer reviewed the report from the third party dependency scan. And the lawyer simply concurred. This is none of my business and I have no more time for it. Karen.
Here is the "problem" routine in full:
``` ULONGLONG MyTickCount64(void) { static volatile DWORD count = 0xFFFFFFFF; DWORD previous_count, current_tick32, previous_count_zone, current_tick32_zone; ULONGLONG current_tick64;
previous_count = InterlockedCompareExchange(&count, 0, 0); current_tick32 = GetTickCount();
if (previous_count == 0xFFFFFFFF) { // count has never been written DWORD initial_count; initial_count = current_tick32 >> 28; previous_count = InterlockedCompareExchange(&count, initial_count, 0xFFFFFFFF);
current_tick64 = initial_count; current_tick64 <<= 28; current_tick64 += current_tick32 & 0x0FFFFFFF; return current_tick64; }
previous_count_zone = previous_count & 15; current_tick32_zone = current_tick32 >> 28;
if (current_tick32_zone == previous_count_zone) { // The top four bits of the 32-bit tick count haven't changed since count was last written. current_tick64 = previous_count; current_tick64 <<= 28; current_tick64 += current_tick32 & 0x0FFFFFFF; return current_tick64; }
if (current_tick32_zone == previous_count_zone + 1 || (current_tick32_zone == 0 && previous_count_zone == 15)) { // The top four bits of the 32-bit tick count have been incremented since count was last written. InterlockedCompareExchange(&count, previous_count + 1, previous_count); current_tick64 = previous_count + 1; current_tick64 <<= 28; current_tick64 += current_tick32 & 0x0FFFFFFF; return current_tick64; }
// Oops, we weren't called often enough, we're stuck return 0xFFFFFFFF; } ```
Let's apply https://en.wikipedia.org/wiki/Abstraction-Filtration-Comparison_test, so stage 1 is Abstraction into individual operations which is what copyright is actually on, not the specific textual form as most programmer think:
1. Persist a count variable across calls of the function.
2. If count is not initialised, store the top four bits of the 32 bit count, and exit.
3. Are the top four bits of the 32 bit count same as last time we were called? If so, exit.
4. Update the persisted count variable with the new top four bits of the 32 bit count, and adjust the value returned to account for the 32 bit wrap so it is accurate.
5. If the top four bits overflowed since the last time we were called, return a failure.
Now apply the Filtration stage where we remove (i) elements dictated by efficiency, (ii) elements dictated by external factors, and (iii) elements taken from the public domain:
1. This is standard programming, and so in the public domain. Remove.
2. The call to fetch the 32 bit count and use of atomics is dictated by external factors. Remove. The only remaining item is the choice of top four bits.
3. All standard programming. Remove.
4. All standard programming and external factors. Remove.
5. Returning from a function is standard programming. Remove. That leaves those top four bits again.
The final part of Filtration stage is whether the choice of four bits is an element dictated by efficiency. Two bits wouldn't allow detection of overflow. Six bits is overkill and detracts from efficiency. So we can remove the choice of four bits.
Finally we move onto the Comparison stage: compare what is remaining after the previous two stages to see if copyright has been infringed. Except, as I just proved, **there is nothing remaining**. So therefore copyright cannot have been infringed by the AFC legal test. The routine is not different from what any skilled programmer would have written if implementing the same thing. Therefore no copyright applies. This use is fair use under US law, de minimis under other jurisdictions.
*Every programmer* should be applying the AFC test to any code they study if they are replicating any of its behaviour. Otherwise they may quite easily infringe on copyright. Simply rewriting a routine does not help. Using a different programming language does not help. Replacing one routine with another which does the exact same thing does not help.
I stand by my claim that no copyright violation has occurred here. There is nothing to hold copyright upon. I look forward to seeing what the SFC lawyers say regarding this specific instance (feel free to send them a copy of the above discussion).
Niall
-- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/
_______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
--- end quoted text --- -- Karen Shaeffer The subconscious mind is driven by your deeply Neuralscape Services held beliefs -- not your deeply held desires.