[Tutor] Borrowing restricted code

[Alex Kleider]

On 2018-12-05 16:45, Steven D'Aprano wrote:
> On Wed, Dec 05, 2018 at 11:22:35AM -0500, Avi Gross wrote:
> 

Those following this thread might like to google "code V2"- the book by 
Laurence Lessig is relevant to many if not all of the disagreements.  
It's also a very interesting read (and free.)

>> I am NOT advocating copying code. Not even "free" code.
>> 
>> I am saying there may be times you want to package the code for 
>> special
>> purposes.
> 
> "Packaging" the code IS copying the code.
> 
> 
>> Perhaps someone can enlighten me on a subtle aspect here.
>> 
>> What does it mean to include something?
> 
> https://en.wiktionary.org/wiki/include
> 
> 
> [... description of how #include works in C ...]
>> The above is not meant to be a precise description but indicates that 
>> your
>> code was rarely all your own. You could literally set it up so if 
>> someone
>> else left their code unguarded, you could arrange to grab text or 
>> library
>> code into your finished executable.
> 
> The precise details of what an individual programming language means by
> "including" code will, naturally, depend on the language in question.
> 
> This is not really the place to go into a detailed description of all
> the possible variations (this is supposed to be a *Python* forum after
> all) but briefly there are at least two kinds of code which we might
> "include": source code and compiled object code.
> 
> When "including" source code, the interpreter might read a command like
> "load spam", look up a file "spam", read the contents into memory, 
> parse
> it and run it through the interpreter as if it had been copied and
> pasted into the original file in place of the "load" line.
> 
> When "including" object code, the compiler (or often a separate program
> called a linker) can make a copy of the object code and insert that 
> code
> directly into the object code it is generating. This is called "static
> linking".
> 
> An alternative is to leave the object code where it is, but instead
> insert instructions for how to access it at runtime. This is called
> "dynamic linking".
> 
> https://kb.iu.edu/d/akqn
> 
> Python's import is (I think) closer to dynamic linking than the others.
> 
> 
>> In python, you can generally have access to the python code of what 
>> you can
>> import or at least to the byte code. But there may be different rules
>> attached to several categories.
>> 
>> If you use "import" you don't so much copy as USE the code. I mean the
>> interpreter pauses evaluating the current file and opens the one you 
>> asked
>> for and reads it as if it were your code.
> 
> That is not entirely wrong, but its not quite right either.
> 
> The action of the import command is surprisingly complex, and so I may
> have got some subtle details wrong. But the high-level overview of what
> the interpreter does when you run "import spam" is as follows.
> 
> 1. Look for an already loaded module "spam"; if the interpreter finds
> one, it creates an new variable called "spam" in the current namespace,
> and assigns that module object to that name. The import is complete.
> 
> # Pseudo-code
> if "spam" in sys.modules:
>     spam = sys.modules["spam"]
>     return
> 
> 
> 2. If no such already loaded module, then search a set of known
> locations for a library called "spam":
> 
> # Pseudo-code
> for location in sys.path:
>     for filename in os.listdir(location):
>         name, ext = path.splitext(filename)
>         if name == "spam":
>             if ext == ".py":
>                 read the source code from spam.py into memory
>                 parse it into bytecode into memory
>                 write out the bytecode to spam.pyc
>             elif ext == ".pyc":
>                 read the bytecode from spam.pyc into memory
>             else:
>                 # other cases handled here, e.g. packages, zip files,
>                 # C libraries (.dll or .so), other extensions etc.
>             # Assuming we get to here...
>             create a module object in memory
>             run that bytecode, using that module object as the 
> namespace
>             cache the module object in sys.modules['spam']
>             spam = module object
>             return
> # no such "spam" module or package found
> raise ImportError
> 
> 
> So you can see that modules are only executed the first time the
> interpreter imports them, not on subsequent imports.
> 
> There really isn't a distinction to make between code treated "as if it
> were your code" and other code. All code is treated the same.
> 
> How could it not be? The interpreter cannot know which modules or
> libraries you wrote, which were collaborative efforts between you and
> other people, and which were written by other people.
> 
> 
> 
>> Some actions are transient. A line
>> like "5+3" evaluates to 8 and you ignore it. But many and perhaps most 
>> lines
>> end up creating instantiations of objects (yes, classes are also 
>> objects)
>> which then sit in memory.
> 
> Or get used and then disposed of by the garbage collector.
> 
> 
>> Functions are also objects and pretty much contain
>> within them everything you need to reconstruct the function if you 
>> know
>> where to look. Is what is copied really different than the original 
>> text
>> used?
> 
> Yes.
> 
> 
>> If you import the base modules that come with python, can you assume 
>> it is
>> freely given with few strings other than the kind discussed?
> 
> There is no need to assume anything, you can read the licence. When you
> start the interactive interpeter, it says:
> 
> Type "help", "copyright", "credits" or "license" for more information.
> 
> 
> so the licence is always at your fingertips.
> 
> If that's too much trouble, then you can trust the millions of other
> people who use Python every day, and believe them when they say the
> interpreter and the standard library are available under a permissive
> licence.
> 
> Unless you are distributing a copy of Python or its libraries to 
> others,
> you don't need to care about the details. That's the point of using a
> permissive licence.
> 
> 
> [...]
>> Back to the main topic, for me. What kind of uses might be considered 
>> legal
>> or at least not worth prosecuting?
> 
> Under the current copyright maximalist domain, virtually nothing is
> legal unless you are the copyright owner, or have a licence from the
> copyright owner. (Disclaimer: I am not a lawyer.)
> 
> You may have the right to *read* the code (if it isn't a Trade Secret),
> but that's about as far as it goes. In principle, copying the code in
> any way (whether by a literal "copy and paste" into your text editor, 
> or
> by merely re-implementing the code from memory after reading it) could
> be deemed to be either copyright infringement or plagiarism or both.
> 
> Especially under the current academic standards of zero-tolerance for
> so-called "plagiarism" in the US, which are extreme and hypocritical.
> But that's off-topic.
> 
> There's a theoretical "Fair Use" right in some countries (but not in
> Australia!) that could allow you to copy small, trivial chunks, perhaps
> as much as 10% of the work, under certain circumstances, but lawyers
> LOVE arguing about what is or isn't Fair Use because such arguments can
> go on and on for months.
> 
> There are also theoretical arguments that the code in question was so
> trivial that there should be no copyright on it in the first place. 
> Just
> as you can't copyright the sentence "I ate a spam sandwich" in 
> isolation
> (only as part of a more substantial work), so you can't copyright a
> trivial isolated line of code. Again, lawyers love arguing about what 
> is
> or isn't trivial.
> 
> In principle, you might even argue independent invention. If you
> happened to come up with substantially the same work independently,
> perhaps because there is only a single obvious way to do something, 
> then
> no copying too place and so you may be deemed to have not infringed
> copyright. (But independent invention is no defence against patent
> infringement.)
> 
> So you can see why many organisations are so paranoid about having
> licences for every line of code they use. Failure to be fully licenced
> could be *incredibly* time-consuming and expensive if they get into a
> legal dispute. The only way to win is to avoid getting into a legal
> dispute in the first place.
> 
> As for what is "not worth prosecuting", there are no copyright police
> who troll the internet looking for copied lines of code. Nobody is 
> going
> to be scanning your Github repos looking for infringement (at least not
> yet, and I'm sure that by now the anti-plagiarism software industry is
> looking to do something like that...)
> 
> There generally needs to be a civil complaint where the copyright owner
> needs to sue you.
> 
> In the USA, the TSA and immigration do look for infringing software (at
> least sometimes) but they mostly care about commercial-scale piracy. If
> the customs official is feeling especially obnoxious and/or diligent,
> they might demand to know why you don't have a Windows licence key on
> your laptop[1] or poke around looking for pirated videos on behalf of
> Hollywood and co. Deep pockets speak loudly.
> 
> But they're not going to open up your Python folder and demand to see
> licences for everything or question whether or not you copy code from
> Stackoverflow without permission.
> 
> 
>> The law in various countries likely
>> differs, Alan and I are definitely using different legal systems but
>> possibly not as different as where Asad is. (His phone number would be 
>> in
>> India.)
> 
> Most countries in the world abide by the Berne convention on
> copyrights, so probably not as different as you may be imagining.
> 
> India, in particular, is a signatory to the Berne Convention, the
> Universal Copyright Convention of both Geneva and Paris, and the TRIPS
> agreement (but not the WIPO Copyright Treaty) so the differences will 
> be
> relatively minor.
> 
> https://en.wikipedia.org/wiki/Berne_Convention
> 
> https://en.wikipedia.org/wiki/List_of_parties_to_international_copyright_agreements
> 
> 
> 
>> Clearly if you make a product and sell it, then borrowing code can
>> be a serious thing.
> 
> Indeed. Most FOSS (Free Open Source Software) projects turn a blind eye
> to trivial non-compliance unless it involves commercial products. Even
> Richard Stallman is probably not going to chase you for copying a few
> lines of GPLed software
> 
> 
>> If you are a student doing a homework assignment and
>> will never use it again, few might care especially if you use small 
>> amounts
>> and don't claim it is your own work.
> 
> I wouldn't be so sure about that, especially in US macademia. (Warning:
> may contain nuts.) Their rules for plagiarism are insanely strict and
> exceedingly hypocritical, because the macademics enforcing those rules
> against students don't even come close to living up to the same
> standards themselves.
> 
> 
>> But the question I would like answered is DOES IT MAKE A DIFFERENCE 
>> how you
>> borrow the use of the code?
> 
> Not legally. Copying is copying, whether you cut and paste in a text
> editor, drag and drop a file from one disk to another, download it from
> the Pirate Bay, or retype it from memory.
> 
> 
>> We talked about the normal intended method:
>> 
>> Load the file into a place on your local machine.
> 
> That's a copy. If you are not permitted to make that copy, you are
> already infringing right there.
> 
> 
>> Write one or more python files and one of them imports it.
>> 
>> A second method I suggested WHEN NEEDED AND ALLOWED is to find the 
>> code you
>> need, perhaps on another machine where you can download it, or in some 
>> other
>> public repository. Copy the minimum you need into your own code, with
>> perhaps enough attribution and explanation.
> 
> That's a copy. If you are not permitted to make that copy, you are
> already infringing right there.
> 
> In addition, "enough attribution" may not be sufficient to avoid 
> charges
> of plagiarism.
> 
> Example: I've seen at least one case of a student given a reprimand for
> plagiarism after giving a one-line quote, acknowledging the author, but
> failing to give a formal reference including page number.
> 
> 
> 
>> Now what about a third way? No edit needed. Simply use a program like 
>> "cat"
>> to concatenate multiple files
> 
> That's a copy. If you are not permitted to make that copy, you are
> already infringing right there.
> 
> (How do you get the copy of the file you pass to cat, if not by making 
> a
> copy?)
> 
> 
> 
> 
> 
> 
> [1] Because it is unthinkable that you might be running some OS other
> than Windows, one which doesn't require a licence key.