Re: [boost] Legal problem with Stackoverflow contribution under the "Creative Commons Attribution Share Alike 3.0" license

Subject: Re: [boost] Legal problem with Stackoverflow contribution under the "Creative Commons Attribution Share Alike 3.0" license
From: Karen Shaeffer (shaeffer_at_[hidden])
Date: 2018-02-20 19:44:19

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.