[Haskell-cafe] blanket license for Haskell Platform?

[Jeremy O'Donoghue]

IANAL, but I'll bite, since I have needed to live with this for quite some
time now. Obviously readers are directed to take independent legal advice
before they do anything for themselves, and all of the other standard
disclaimers.

On 25 October 2011 11:58, Eric Y. Kow <eric.kow at gmail.com> wrote:

> On Tue, Oct 25, 2011 at 21:46:21 +1100, Ivan Lazar Miljenovic wrote:
> > > - My user is concerned that a large number of having a large number of
> > >  individual licenses even though textually identical modulo author,
> > >  date, etc would mean a big hassle getting their lawyers and their
> > >  user's lawyers to sign off on each and every license
> >
> > Why do their lawyers all need to sign off individually for BSD
> > licenses (which if memory serves all platform libraries have to be
> > licensed under, or some variant thereof)?  At most it just means they
> > need to lump them all into one big text file somewhere saying which
> > libraries they used... (then again, IANAL, and don't charge by the
> > hour to consider these complex technical questions :p).
>

The first thing to say is that this is actually a very responsible attitude
on the client's part. When legal review is conducted it is not just the
license which needs to be checked:

   1. What implications does this license carry for my business model. BSD
   is considered benign in this respect. GPL and LGPL work for some models but
   not others.
   2. Does the purported copyright holder actually have the right to issue
   the software under the given license.

The second is much more time consuming. It is straightforward to do this if
the software in question was written by one person, but when contributions
come from multiple people it becomes more difficult. For example if a
project receives a contribution which the contributor did on company time,
they may not even have the right to make that contribution (because the
employer paid for, and hence owns it). There have similarly been cases where
a developer has taken code from, say, a GPL project and imported it into
their own differently licensed project.

This second case is particularly difficult, as there *may* be cases when it
is acceptable (e.g. under fair use in some jurisdictions) to extract small
portions of a work and re-use them, but in most cases the developer simply
does not have the right to make the contribution. There are sub-cases of
these, for example where one developer has removed the copyright notices
placed by the original author, even though licensing has been kept the same.
This is legal (if ethically dubious) in some jurisdictions and illegal in
others.

A related issue: can a project *prove* that contributors have all formally
licensed their code contributions under the same license? As far as the law
is concerned, you really need this in writing, or something very close to it
(e.g. e-mail with full header information).

Personally I think we should give praise and recognition to anyone who
thoroughly checks and complies with the license attached to a piece of code
as they are taking care to respect the wishes of the author. I get much more
fired up about those who simply break licenses and hope they don't get
caught.


> I find the whole thing baffling myself.  I'd thought this would be the
> sensible thing to do, but I guess when it comes to these licensing
> things it's not the actual pain that counts, but the perceived potential
> pain.  Know what I mean?
>
> It's similar to the "won't touch with a 10ft pole" attitude to the GPL
> that some entities may take.  It's basically a precautionary "la la la;
> I can't hear you" or a conservative stance which consists of
> "I don't understand this stuff, so I'm going to do the thing that seems
> safest to me", which may or may not be a reasonable reaction...
>

I am not sure that anyone 'understands' the GPL with real certainty [1]. Key
questions: when does a work fall into the category of 'derived' under the
GPL and when does it not do so? If I make money from licensing Intellectual
Property, what are the consequences of code which grants an implicit patent
license? Neither of these clauses of the GPL has been properly tested in a
significant legal jurisdiction (and anyway, a Code Napoleon style
jurisdiction might take a different stance than under UK/US style Common
Law).



> Well, it would need copyright attribution/agreement of everyone that's
> ever committed code to any library/application to the Platform (which
> is why so many large projects want it) to re-license them AFAIK, which
> may be difficult.

 I could just say it'd be unrealistic.  Just trying to be thorough.
>

It may be unrealistic, but it would actually be a very good idea - although
completely unnecessary if we wish to continue to avoid success at all costs
:-)

[1] This a strength of the GPL. It was developed to achieve a specific
political goal, and has been hugely successful in doing so.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20111025/f78c18d5/attachment.htm>