Niall, I confirm what Karen said: the scanning software automatically flagged your contribution. As Karen explained such software are able to flag using different techniques, one is code signature comparison with a database of code signatures which they explained me is automatically enriched by web repositories and forums scanning. I do not have the information how your contribution has been flagged. And for the things to be clear this is not the legal department of my company which said it's a problem, this is an independent lawyer office, different than the external company which made the scan. I do not agree with your approach to check the IP of a function piece by piece and saying as each piece is not covered by IP, the assembly of all pieces is also not covered by IP. If you compare to a patented hardware for example, it is probable that each individual piece is not covered by any IP or patent, but the assembly of all pieces make something original and provide a new feature which can be patented. What lawyers explained me is that there is a risk, when there is a risk the decision could be lawyers against lawyers, and companies do not like such risks. I will now stop this discussion, my company found a solution for delivering our software products without this polluting contribution. I am sure Boost contributors or Steering Committee will make the good decision. Dominique -----Original Message----- From: Boost [mailto:boost-bounces@lists.boost.org] On Behalf Of Niall Douglas via Boost Sent: mardi 20 février 2018 20:07 To: Boost Developers List Cc: Niall Douglas; Boost Steering Committee Subject: Re: [boost] Legal problem with Stackoverflow contribution under the "Creative Commons Attribution Share Alike 3.0" license
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.
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
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. 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. 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