Re: Ada and licensing + how to keep the RTL license from propagating :-)

[Markus E L <development-2006-8ecbb5cc8aREMOVETHIS@ANDTHATm-e-leypold.de>]

Simon Wright wrote:

> Markus E L <development-2006-8ecbb5cc8aREMOVETHIS@ANDTHATm-e-leypold.de> writes:
>
>> Simon Wright wrote:
>
> On the whole I think we agree up to here from previous posts ...
>
>>> And hence my suggestion that a .o could inherit (GM)GPL-ness
>>> from the library.
>>
>> But have the unlinked modules already included relevant parts of the
>> generics (their body, not their interface)? If so, wouldn't that
>> mean that truly independent compilation is not possible with GNAT?
>
> If you say
>
>   package My_Integer_IO is new Ada.Text_IO.Ineger_IO (My_Type);
>
> it seems hard to argue that you're not including p/o it rtl, whatever
> the compiler.

Depends. I admit (as I did in my last post) that the _letter_ of the
GPL might allow or encourage that reading. But what I've been aiming
at, is, that it seems odd from a software engineering point of view
that _using_ an interface makes the using module a "derived
work". Never mind the "include" which either refers to something only
C does or a an implementation detail of the compiler which might
choose to put the complete generic package into the sompiled
compilation unit) - or it might not.

Even using a generic package with new is (from a user perspective)
primarily a use of interface. The package announce the types and
operations it has available and at that point my program is only duly
noting it, nothing more. 

The point I'm aiming at, is, that if this sets a precedent, I see
hardly any barriers to GPLing (or restricting by license) knowledge
about protocols (again Samba comes into mind).


>> Something else: I could add the following at multiple other places in
>> the thread, but since I've already taken the effort to write a
>> message, I'll add it here:
>>
>> What hasn't been mentioned yet, is the ultimate GPL circumvention
>> device (it has been hinted at, though) and that is the contract
>> between developer and customer:
>>
>>   - Sell them closed _proprietary_ code and absolutely bind them
>>     contractually not ever to redistribute that code.
>>
>>   - Seperately sell them a maintenance contract for a Gnat
>>     installation (even and especially take GPL Gnat: Not forbidden to
>>     sell a mini-maintenance contract for that to other people) and
>>     install Gnat at their site.
>>
>>   - Offer them a third service contract for maintaining software
>>     packages at their site, specifically by compiling and packaging
>>     the software in question at their site.
>>
>> Since bespoke customers will insist on getting source anyway,
>> exactly in this case you'll get maximal protection and none of the
>> spill over of the license from the runtime.
>
> The developer isn't distributing binaries that should come under the
> GPL but the customer certainly would be!

Ah yes -- if it is not for in-house use, e.g. deployed embedded in
other products.

This was a only thought game anyway.


>> Since I assume AdaCore stripped the linking exceptions because they
>> thought they got pulled over the table by free riders among their big
>> customers (they can't seriously hope for small software houses and
>> small projects to pay their buy-yourself-out-ofGPL maintenance fees),
>> this is rather amusing: It's especially those cases in which (a)
>> distribution of the better Gnat within the organization cannot be
>> controlled effectively (as long as enough people keep mum and don't
>> snitch to AdaCore) and it's exactly those customers that won't want to
>> redistribute[1] but keep their source close, so will be happy with GPL
>> Gnat[2]. These people won't pay to get rid of the GPL, but rather to
>> get maintenance so the buy-and-get-linking-exception incentive won't
>> work for them.


> My (fairly large) employer is anxious to comply with the terms of the
> contract with AdaCore, which is for support and for access to GMGPL'd
> tools so that we can make proprietary products. We have no wish at all
> to become embroiled in lawsuits about copyright or the GPL. Our

The point I see in that is, that in large projects the cost for
licensing the compiler is in comparison not very large. As I said
earlier, my impression is, that dropping the linking exception from
the public compiler version mainly screws the not-so-large
not-customers-anyway part of the community [1]. 

And the "we don't tell when the license changed and what do you mean
by linking exception anyway?"  attitude of AdaCore as I experienced it
makes it rather difficult to determine the right point for a GMGPL
fork (on the other side the community doesn't seem to be really
interested, so I admit, AdaCore perhaps has understood the community
better than I do, or perhaps GtkAda users (I was talking about GtkAda
when I talked about a fork) that can't/won't buy the rather expensive
AdaCore support and are bothered by the elimination of the linking
exceptions are just not enough).


> customers insist on knowing the IPR status of the bespoke products we
> deliver to them (of course, they get the source, and they're not going
> to deliver to anyone else -- at any rate, as someone said, not in the
> sense used here!).

>
> Don't forget that the suite is entirely GPL-d so it would be legal to
> give a copy to every person in the organisation who was not working on
> an AdaCore-supported project! 

> But we don't want to do that either -- for a start, most of them
> don't use Ada; and for seconds, management don't really get the GPL
> and think they have to pay to use.

This is the most funny part :-)).  And dovetails nicely with [1]
above.


Regards -- Markus