Licensing of Haskell code
I should mention to contributors to the Haskell community that the precise licensing of their code can matter a lot. With my commercial company hat on, we tend to have to avoid using Haskell stuff that is GPL'd, and I worry generally about proliferation of such code impeding efforts to have Haskell take off in industry. BSD-style licenses are a lot easier because they don't "infect" other code from the same application, which may even be from other commercial partners, etc. (The LGPL is probably better in this respect, too.) With my altruistic idealist hat on, I am glad that the GPL impacts the commercial software industry, I think it was generally a good idea, and maybe it's for the greater good even it disadvantages some companies. And, if a company doesn't like that something's GPL'd, they can track down the authors and negotiate to be licensed the code on some other basis. My point is not to tell people how they should license their code, although I'd be happy to discuss that over on haskell-cafe. I hope I can avoid opening too large a can of worms here. My points are more that: It matters which particular "opensource" licence you pick, so review them and choose carefully, based on your beliefs and ideals. It would be really great if it were somehow easy for Haskell developers to be easily able to check the licensing status of various bits of code - tools, libraries, etc. - that their software uses, or that they are thinking of having it use. It's not too hard to look into now, but after the Haskell community and hierarchical libraries have grown much more I don't know if one might wish that something had been built in early on that somehow eases semi-automated checking. -- Mark
Mark Carroll <mark@chaos.x-philes.com> writes:
I should mention to contributors to the Haskell community that the precise licensing of their code can matter a lot.
With my commercial company hat on, <snip> With my altruistic idealist hat on, <snip>
If you consider software a service rather than a product, GPL is the best license for both hats. This has been working for me for the last few years.
It would be really great if it were somehow easy for Haskell developers to be easily able to check the licensing status of various bits of code -
Python's dist-utils includes licensing info, sounds like a useful feature for the Haskell dist-utils. -- Shae Matijs Erisson - 2 days older than RFC0226 #haskell on irc.freenode.net - We Put the Funk in Funktion 10 PRINT "HELLO" 20 GOTO 10 ; putStr $ fix ("HELLO\n"++)
On Monday 19 May 2003 4:01 pm, Shae Matijs Erisson wrote:
If you consider software a service rather than a product, GPL is the best license for both hats. This has been working for me for the last few years.
Please let us keep this discussion on the topic of tagging libraries with their different licenses, reasoning about combinations of licenses, etc. We have had flame wars^H^H^H^H^H^H^H^H^H^H discussions about the right license to use for Haskell libraries before. Agreement has not been reached and is unlikely to be reached because different licenses serve different goals. I think there is little point in rehearsing the arguments. Let us accept that we will have multiple licenses and move on to more fruitful subjects like how to handle multiple licenses. One way of dealing with multiple licenses is described in section 6.5 of this document http://www.linuxhq.com/ldp/howto/Module-HOWTO/basekerncompat.html This is about licenses used in linux kernel modules. It mentions a way of enforcing the GPL's restrictions on linking: they built support for the GPL into the linux kernel linker. I suspect that this is more than we need. For our purposes, it would probably be sufficient to have a haddock-like tool gather all the licenses listed in module headers and present them to the user. [For those who don't know, haddockized modules typically contain a module header which includes information such as the author, stability of the API, portability and the license. It would probably be trivial to modify Haddock to dump out this information in a form that could be processed by external tools.] Details: 1) The default assumption (if no module header is present) should be somewhat pessimistic since it implies that we have no license to do anything at all with the code. 2) If we standardize the meaning of the license descriptions, we can add some simplification rules like: GPL + MIT = GPL # I think this is true. BSD + MIT = BSD # This may also be true x + x = x # This says that we can delete any duplicates All this does is allow a list of 50 (say) licenses to be boiled down to one or two licenses for the program author to ponder. Since the tool returns a set of licenses, there's no need to provide rules for every possible combination of licenses. This avoids the need to somehow force-fit all the licenses in the world into a single lattice. 3) It might be useful to allow module authors to add a second module header which says what license(s) they expect to govern their module. A tool could report any mismatch. Obviously, this would be useful for program authors who wish to check that their program can be released under a given license. It would also be useful for library authors who want to release their code under a BSD-style license and want to check they don't accidentally rely on a GPL library. -- Alastair Reid
In article <200305201007.14918.alastair@reid-consulting-uk.ltd.uk>, Alastair Reid <alastair@reid-consulting-uk.ltd.uk> wrote:
GPL + MIT = GPL # I think this is true. BSD + MIT = BSD # This may also be true x + x = x # This says that we can delete any duplicates
By "+" I assume you mean "must comply with at least one" rather than "must comply with both"? OK, this may not be immediately practical, but... as contracts, would it be possible to express licenses in a Haskell-like language? Didn't Simon PJ do some kind of work on this? There seem to be interesting covariant/contravariant properties here, for instance, if I require you to allow A to anyone who does B, then that is satisfied if you allow more than A to anyone who does less than B. Just an idea anyway. -- Ashley Yakeley, Seattle WA
Alastair Reid <alastair@reid-consulting-uk.ltd.uk> wrote:
GPL + MIT = GPL # I think this is true. BSD + MIT = BSD # This may also be true x + x = x # This says that we can delete any duplicates
On Friday 23 May 2003 1:37 am, Ashley Yakeley wrote:
By "+" I assume you mean "must comply with at least one" rather than "must comply with both"?
I was thinking of a situation like: Suppose you have a program containing module A and module B. To make it concrete, let's further assume: Module A has license GPL and module B has license MIT. I want to determine: What license governs the complete program? We all know from having seen enough examples that it's the GPL license. That's what I meant when I wrote: GPL + MIT = GPL i.e., if you link 2 modules one governed by GPL and the other governed by MIT then the result has license GPL. That is, '+' means 'must comply with both'. The proposal was that you make a list of all the modules in your program. From this you make a list of all the licenses of all the modules. You then apply simplification rules: - eliminate duplicates - where one license is strictly stronger than another, keep the stronger This results in a list of licenses which the programmer or his lawyer can puzzle over. Notes: 1) Conceivably, there could be a license where it matters whether A imports B or B imports A but I'm not sure how a lawyer would interpret this in the context of higher-order functions and, in any case, I've not seen such a license so, as a first approximation, I'm going to ignore the difference. 2) Similarily, a license might distinguish between dynamic linking and static linking and, again, I'm going to ignore the difference. -- Alastair Reid
On 2003-05-19T10:20:01-0400, Mark Carroll wrote:
I should mention to contributors to the Haskell community that the precise licensing of their code can matter a lot.
It matters which particular "opensource" licence you pick, so review them and choose carefully, based on your beliefs and ideals.
Thanks for the reminder! The following summary of the goals underlying various licenses might also help: http://www.dina.dk/~abraham/rants/license.html
It would be really great if it were somehow easy for Haskell developers to be easily able to check the licensing status of various bits of code - tools, libraries, etc. - that their software uses, or that they are thinking of having it use. It's not too hard to look into now, but after the Haskell community and hierarchical libraries have grown much more I don't know if one might wish that something had been built in early on that somehow eases semi-automated checking.
I agree. It seems that even just making sure that every file contains a copyright statement would help. -- Edit this signature at http://www.digitas.harvard.edu/cgi-bin/ken/sig http://weblog.holopedia.org/
while creative commons - http://www.creativecommons.org/ - don't recommend the use of their licenses for software - http://www.creativecommons.org/faq#faq_entry_3646 - they do provide information on an rdf basd metadata scheme that encodes licence details - http://creativecommons.org/learn/technology/metadata/implement and http://creativecommons.org/learn/technology/metadata/ andrew Mark Carroll <mark@chaos.x-philes.com> writes: [...]
It would be really great if it were somehow easy for Haskell developers to be easily able to check the licensing status of various bits of code - tools, libraries, etc. - that their software uses, or that they are thinking of having it use. It's not too hard to look into now, but after the Haskell community and hierarchical libraries have grown much more I don't know if one might wish that something had been built in early on that somehow eases semi-automated checking.
On Mon, 19 May 2003 10:20:01 -0400 (EDT), Mark Carroll <mark@chaos.x-philes.com> wrote:
It would be really great if it were somehow easy for Haskell developers to be easily able to check the licensing status of various bits of code - tools, libraries, etc. - that their software uses, or that they are thinking of having it use. It's not too hard to look into now, but after the Haskell community and hierarchical libraries have grown much more I don't know if one might wish that something had been built in early on that somehow eases semi-automated checking.
Another question is what should happen if there are two "competing" libraries that do the same thing but have different licenses. For example, the existing library Foo.Bar is GPL, and someone needs a BSD version so writes their own. Cheers, Ganesh
participants (7)
-
Alastair Reid -
andrew cooke -
Ashley Yakeley -
Ganesh Sittampalam -
Ken Shan -
Mark Carroll -
Shae Matijs Erisson