Re: How to get Ada to ?cross the chasm??

["Dan'l Miller" <optikos@verizon.net>]

On Wednesday, April 18, 2018 at 9:36:12 AM UTC-5, Simon Wright wrote:
> Simon Clubley writes:
> 
> > Also, as far as I can see (and I am willing to be corrected here if I
> > am wrong) it means that you can't even write a library in Ada under
> > something other than the GPL if you are going to use the Community
> > version. As soon as you compile the library source with the Community
> > version, it falls under the GPL and hence any software using your
> > library also falls under the GPL.
> 
> There are a host[1] of licenses compatible with the GPL.
> ...
> [1] https://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses

Well, not so fast.  Clubley's “fall under” is correct.  Although Wright is narrowly correct, the narrowness of the precise correctness of “compatible with” is highly misleading.

How many months have 28 days?  The narrowly-precise correct answer is:  all of them.  This style of mathematically-narrow correctness is what is at play here with “compatible with the GPL”.  The best correct answer is of course to transparently answer both interpretations in one fell swoop:  all of them and only February on non-leap-years.

https://www.gnu.org/licenses/gpl-faq.html#WhatDoesCompatMean

GNU's “compatible with the GPL” can very easily be misinterpreted.  First let's consider licenses that are incompatible with the GPL.  If you statically link GPLed object code with, say, Microsoft EULAed object code, you have prima-facie violation of the GPL right from the git-go:  you cannot release the source code for the EULAed software, because (even if you have the source) the EULA prohibits publicly releasing the EULAed source code.

Next let's consider licenses that are deemed “compatible” with the GPL but that lack the copyleft demand to released source code.  Let's take, say, the Boost Software License (BSL).  Normally, if you modify Boost source code, you are not compelled in any legal way to release those modified lines of source code to anyone.  But if you statically link that BSLed object code with GPLed object code, you have the •opportunity• to do what the GPL absolutely requires:  release your modifications to the Boost source code publicly.  You don't have a prima-facie violation of the GPL yet, hence BSL is so-called “compatible” with the GPL.  You only violate the copyleft provisions of the GPL if you of your own volition refuse to publicly release your modifications to the BSLed source code; hence it was not the BSL that was the root cause of the violation of the GPL's terms; hence the BSL is compatible with the GPL's copyleft terms.

(Note that there exist other license-of-other-code mechanisms of being prima facie in violation of the GPLv3 right from the git-go (e.g., patents; prohibitions on reverse engineering); thus there exist other ways of a license being incompatible with the GPL.  I am simply utilizing the copyleft's demand to publicly release the source code as the most-often-encountered example, and the one that Clubley was mentioning above.)

Clubley's “fall under” more accurately captures what is going on here.  “Falls under” does •not• mean:  all licenses of statically-linked object code are retroactively retexted as now GPL itself, requiring new licensing text to be issued by the original copyright holder(s).  Clubley's “falls under” ••does in fact•• mean:  the copyleft terms of the GPL apply to nonGPLed object code that was statically linked to the GPLed code, which is clearly the meaning that Clubley was intending to convey:  the not-originally-copylefted source code becomes copylefted here by its object code being statically linked with copylefted-from-the-git-go object code.  Colloquially, this transitivity of spread of the copyleft's demand for public release of source code of not-otherwise-copylefted source code is what is termed ‘viral’ pejoratively.

(Btw, I limit these examples to static linking within an executable.  1) Dynamic linking GPLed code to an otherwise not-copylefted executable and 2) dynamic linking not-copylefted object code to an otherwise GPLed executable both require vastly more detailed analysis of precisely how the dynamic linking transpired and what knew what about the interfaces across that boundary, which even gets into the thorny topic of the Oracle-v.-Google case of whether declarations of subroutines can be copyrighted, and if they can, what is and is not fair-use of those declarations of subroutines.  The vast majority of the time [e.g., not LGPL; the executable being the link-loader rather than the OS; the interface across the DLL is parameterless procedure with no string identifier name such as indexing into an array of addresses where that array starts at a well-known address]—the DLL case is almost exactly the same as the statically-linked case regarding the spread of the copyleft's release-the-source-code demand to otherwise not-otherwise-copylefted object code and thus to its not-otherwise-copylefted source code.)