New copying license for classes/modules: CGPL
Wouter Scholten
Summary: CGPL license for classes/modules/subroutines
Introduction
============
The GPL/LGPL licenses are not adequate for classes as these must be
compiled into a program, but they are really used in the same way as a
library: to get access to already coded functions. Similarly for non-OO
programming, small utilies can easier be compiled into a program (and
possible altered a bit) than linked with a shared lib (you must make
sure the target system has the lib you use etc). An example would be GIF
decoders and time/date functions.
I therefore suggest a CGPL license which says:
- using the classes (or subroutines, modules, ...) for any product is
allowed, commercial, GPL, LGPL, BSD, etc.
- Any enhancements to the classes must be released freely with source by
uploading to a server like sunsite.unc.edu (this is stronger than the
GPL/LGPL requirement)
- additional classes made in a program using them, need not be released.
There are some other cases where the CGPL should also be used, like
wrappers for libraries. These need to be compiled into a program
although it's clear they are used like a library, but the code must be
compiled into the program. This latter requirement means the LGPL
doesn't work (it becomes automatically equivalent to a GPL).
Rationale
=========
1. It should not be necessary to reinvent the wheel for any programmer.
Creativity should go into the toplevel stuff, not in reinventing the
wheel for the umpteenth time.
2. Now, there's no or almost no incentive for commercial programmers to
release their stuff freely. Now, if we have a CGPL, then they
would/could also
contribute.
3. The top level/creative/specific stuff should fall under the license
one wants (Comm., GPL, LGPL, BSD, whatever)
4. We could have a common base for BSD/GPL versions of programs.
Duplication of efforts between *BSD and Linux would be lessened.
Which license for what part?
============================
Well, it's your own choice, but CGPL for the really general
things, Commercial/GPL/LGPL/BSD/other for the higher level stuff seems
appropriate.
Completely CGPL'ing would be possible but only useful in some cases.
What should the license look like?
==================================
Mike Stump suggested:
- Try the libgcc trick. Do a standard GPL, then add:
-
- /* As a special exception, if you link this library with other files,
- some of which are compiled with GCC, to produce an executable,
- this library does not by itself cause the resulting executable
- to be covered by the GNU General Public License.
- This exception does not however invalidate any other reasons why
- the executable file might be covered by the GNU General Public
License.
- */
-
- to each file, just after the standard opening. You'll probably want
- to modify that slightly to target what it is you want to allow.
Note,
- once you do this, you cannot incorporate normal GPL or LGPL code,
- without the copyright holder's explicit blessing. If you own it
- (wrote it), then there is no problem.
-
- It works well for libgcc.a and libstdc++, the runtime libraries for
- gcc and g++, and has withstood the test of time IMHO.
In the CGPL case, the 'compiled with GCC' should be removed, and 'link
with'
should be replaced.
It should probably look somewhat like this:
GPL +
/* As a special exception, if you link a complete library made from
these classes/modules/functions with other files,
or compile these classes with other files to produce an executable,
this library does not by itself cause the resulting executable
to be covered by the GNU General Public License. This will be
covered by the license that is implied by the license on the components
not obtained from the library.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
Any enhancements to the classes/library must be released freely
with
source by uploading to a server like sunsite.unc.edu, immediately
after releasing any program based on these enhanced classes.
*/
i.e., the components used would remain under the CGPL, and the
executable falls
under the same license as the top level stuff (*GPL, BSD,..)
Furthermore, I want to avoid the vagueness of the GPL/LGPL about
releasing source, which can be 'delayed' (see the 'What does the GPL
really say' discussion in comp.lang.ada)
Any suggestions or improvements ?
BTW, I don't like the standard GPL opening for all files. This adds an
enourmous amount of text for mostly small files. Can one say, 'see the
file CGPL explaining the license for this file', where the file CGPL
contains a reference to the GPL, with the addition as above ?
Wouter
Robert Dewar
Woulter says
<<The GPL/LGPL licenses are not adequate for classes as these must be
compiled into a program, but they are really used in the same way as a
library: to get access to already coded functions. Similarly for non-OO
programming, small utilies can easier be compiled into a program (and
possible altered a bit) than linked with a shared lib (you must make
sure the target system has the lib you use etc). An example would be GIF
decoders and time/date functions.
I therefore suggest a CGPL license which says:
- using the classes (or subroutines, modules, ...) for any product is
allowed, commercial, GPL, LGPL, BSD, etc.
- Any enhancements to the classes must be released freely with source by
uploading to a server like sunsite.unc.edu (this is stronger than the
GPL/LGPL requirement)
- additional classes made in a program using them, need not be released.
There are some other cases where the CGPL should also be used, like
wrappers for libraries. These need to be compiled into a program
although it's clear they are used like a library, but the code must be
compiled into the program. This latter requirement means the LGPL
doesn't work (it becomes automatically equivalent to a GPL).>>
Robert replies
One thing that people seem confused on is that GPL is simply a form of license
used by some people because it suits their purposes. If you are writing a
piece of code, you are the author and copyright holder (assuming no prior
agreements to the contrary), and you can decide how to license it. You can
use the GPL if it suits your purpose, but if it doesn't, you can modify it
in any manner you like. So if you are writing something where you wish to
use a modified version of the GPL, you can go ahead and do it. It is helpful
if you make clear what your modifications are, so that people are not confused.
As to the class issue itself, in Ada of course, the equivalent problem does
not exist, since Ada works with semantic connection using WITH, rather than
by copying text.
However, with Ada, the issue of generics does arise, not because text is
copied, but because the code is copied into your program, and for GNAT we
use a specially modified version of the GPL for the library that makes
clear that generics do not cause a problem:
-- As a special exception, if other files instantiate generics from this --
-- unit, or you link this unit with other files to produce an executable, --
-- this unit does not by itself cause the resulting executable to be --
-- covered by the GNU General Public License. This exception does not --
-- however invalidate any other reasons why the executable file might be --
-- covered by the GNU Public License. --
So if you have some software that you want to release under your "CGPL",
just go ahead, no debate is required, no agreement from anyone else is
required, and probably the most useful way to advance the discussion is
to release the sotware, and then let users point out any problems.
Paul Fernhout
Wouter -
Your idea sounds similar to the Educational Economy License embodied in
Squeak Smalltalk. Basically, you are free to do anthing you want with
that code (including put it in a commerical product), except that if you
distribute a modified version, any changes to the base classes, ports,
or translations need to be released back into the source code pool for
others to use under the same license. This is a more commercial
friendly license. In general, I think the GNU license doesn't handle
the concept of OO programming well, although the LGPL (libray license)
coudl be stretched to apply to classes - although in Smalltalk, it is
not clear at what point the library ends and your changes begin.
The EOE project focuses mostly on Java right now, but the concept is
more broadly applicable. You can find out more about the EOE at:
http://trp.research.apple.com/edeconomy/info.html
Why I am interested in this issue:
We have a garden simulator for Windows (downloadable at no charge) at:
http://www.gardenwithinsight.com
We are in the process of trying to decide how to distribute the code.
Much of the original source for our agricultural models was translated
from public domain Fortran to Delphi Pascal. We are trying to decide
whether to:
* charge for using the source
* copyleft the source
* put the source under a Squeak/EOE license
* put the source in the public domain
We would also like to build a user community who improves this source
and shares their improvement (thus in part making our knowledge of the
system (as its authors) more valuable). We hope to create a new standard
for quality, well written mathematical models to be used for education
(for example, we include units in all the variables). Also, we would
like to port the code to a framework like Squeak (or perhaps though less
likely GNU Common Lisp) that allows end users to easily change the
models without having to purchase a compiler (like Delphi), and also
lets us build up nice user-friendly simulation development tools.
In general we have stayed away from GNU code because we might want to
release a commerical product (although that interest is waning). We
think others may feel the same, and that is why we are leaning toward a
EOE-like license.
However, just because we are looking at releasing the source under a
free license, we have the documentation on a downloadable but not
redistributable license (and hope someday to sell a book related to this
project) - similar to the many GNU books that are out there that cannot
be copied. We have put six person years into this project at our own
expense and still hope for some return - even if it may be on the other
side of a leap of faith. Mostly we would like a monetary return so we
could keep doing the same sort of work making educational simulations of
other things (like space habitats).
I guess if we had planned to release all this source for free in the
first place we might have considered GPL and doing it in a GPL'd tool
(like GNU Common Lisp, GNU C++) or GNU Smalltalk, as well as
incorporated GNU code. But somehow, that seemed like too much of a
commitment to the GNU cause. The Squeak/EOE license doesn't require
that commitment up front. There is also part of the EOE concept not yet
worked out that says if you don't want to give your changes to the base
back, you have to pay someone something for that prioveledge - giving
you licensing options all the way to the end of the project.
I really like the general GNU concept and the notion of an ever
increasing storehouse of free information (not just software, but also
patents, art work, etc.) like others have mentioned before in this
newsgroup. Someday this could become the heart of an information
management system at the heart of free communities. Somehow though,
excluding the information from use by the commercial world makes people
(like me) take an either or approach - either use it entirely, or don't
use it at all. There is not much middle ground; that makes it hard to
get started on using GNU stuff (such as even to decide to spend time
evaluating GNU code for useability). The advantage of the EOE license
is that there is benefit to commercial ventures to stay involved with
the EOE stuff (because they can use it fairly easily and with only
limited responsibilities), and so there may be a greater energy to
improve such software.
-Paul Fernhout
Kurtz-Fernhout Software
===========================================================
Developers of custom software and educational simulations
Download version 1.0 of our Garden Simulator for Windows from:
http://www.gardenwithinsight.com
Bertrand Meyer
Robert Dewar wrote:
> However, with Ada, the issue of generics does arise, not because text is
> copied, but because the code is copied into your program, and for GNAT we
> use a specially modified version of the GPL for the library that makes
> clear that generics do not cause a problem:
arise for Eiffel. The language is designed so that the code of
generic classes need not be duplicated for different
"generic derivations" of the same generic class
(i.e. different types obtained by providing different generic
parameters, as in LIST [BOAT] and LIST [PERSON]).
Our implementation, and I believe others too, indeed do not
duplicate the code in such cases. Nor is there any need to
"copy the code into your program".
(Please note that this observation includes no criticism or even
mention of Ada; its intention is simply, since Robert Dewar's
message was cross-posted to comp.lang.eiffel, to address his
point insofar as they apply to Eiffel.)
More generally I think that the idea of adapting the Gnu
Public License to cover reusable O-O components is excellent.
--
Bertrand Meyer, ISE Inc.
ISE Building, 2nd floor, 270 Storke Road, Goleta CA 93117
805-685-1006, fax 805-685-6869, <Bertran...@eiffel.com>
http://www.eiffel.com
Franck Arnaud
> More generally I think that the idea of adapting the Gnu
> Public License to cover reusable O-O components is excellent.
I'm not sure it is a good idea from a legal viewpoint.
The GNU licence has one very clear goal: having as much (ultimately all)
software as possible fall under the GNU conditions -- everything
available as source code under the GNU conditions (recursively).
This may be a valuable goal for some people, but it has several
disadvantages:
(1) It does not mix well with other approaches (either real freeware or
plain public domain or, at the other end of the scale, commercial
software)
(2) It's a rather condescending approach, relying on some form of legal
threat (using the law to enforce an ideology). Personally I prefer
approaches that rely on people's civic sense rather than bullying.
Adapating it is a bit silly, it's much more sensible to use or write
other licences if one prefers other forms of distribution (plain public
domain does not even require any licence). You sometimes see software
with a "modified" GNU licence were the addenda more or less cancels the
whole legal base of the GNU licence! It's a bit like defining Eiffel by
starting from a C++ manual and describing the differences...
David Kastrup
Franck Arnaud <Franck...@stratus.com> writes:
> > More generally I think that the idea of adapting the Gnu > Public
> License to cover reusable O-O components is excellent.
> I'm not sure it is a good idea from a legal viewpoint.
> The GNU licence has one very clear goal: having as much (ultimately
> all) software as possible fall under the GNU conditions --
> everything available as source code under the GNU conditions
> (recursively).
> This may be a valuable goal for some people, but it has several
> disadvantages:
> (1) It does not mix well with other approaches (either real
> freeware or plain public domain or, at the other end of the scale,
> commercial software)
> (2) It's a rather condescending approach, relying on some form of
> legal threat (using the law to enforce an ideology). Personally I
> prefer approaches that rely on people's civic sense rather than
> bullying.
Using the law to enforce an ideology? Sorry, but you're way off
here. Nobody forces you to use GNU software. No, that's not even the
issue. Nobody forces you to take GNU software, modify it *and*
distribute modified versions, and only this last case is where the
licence indeed prohibits you to do this unless you do so under the
original licence. The licence does not even forbid you to demand
large gobs of money for your modified version. It does not forbid you
to modify the code and use it for your own purposes.
There are no legal threats involved at all. All that the GPL defines
is what *rights* are given to a user of the software. Those rights
are far more numerous than the rights a user of commercial software
gets (for example, you may sell an arbitrary number of copies of the
software).
The only "threat" involved here is the implicit threat that failing to
comply with the licence makes you act contrarily to the intentions of
the copyright holder. You encounter this threat almost always when
buying books, records, software (except public domain software).
I cannot see the GPL as "bullying". Your "appealing to civic sense"
seems to mean putting it in the public domain and asking people to
please feel bad about it (if convenient) when they trivially change it
(or not even that), put an "you touch this software, you sold your
soul" type of licence on it and demand search warrants for every
suspected copy of ""their" software around which might possibly be
used on more than one computer, or in any way not intended by the
"added value" person.
If the GPL "uses the law to enforce an ideology" that thinks this is
not necessarily what the author of the software wants, I cannot
conceive this as terribly bad.
Whether some authors would prefer a different licence for works that
are intended to be used only as components of a larger part, is a
different sort of thing, and of course entirely depends on the author.
But for "stand-alone" applications, the GPL is certainly not
restricting the customer in serious ways. Yes, it may put a few
limits on what you are allowed to do with the software, but these
limits are much much less strict as you get with commercial software
(where you are not even allowed to reverse engineer the source code,
let allone get it).
--
David Kastrup Phone: +49-234-700-5570
Email: d...@neuroinformatik.ruhr-uni-bochum.de Fax: +49-234-709-4209
Institut für Neuroinformatik, Universitätsstr. 150, 44780 Bochum, Germany
Franck Arnaud
David Kastrup:
> Nobody forces you to use GNU software.
Yes, a bit like nobody forces anyone to use Microsoft software. In
practice, it's hard (or very expensive) to use Unix without using GNU
software. Unix is useful to a lot of people, who more or less have
practically no choice but to use GNU software.
> There are no legal threats involved at all. All that the GPL defines
> is what *rights* are given to a user of the software.
Yes, but there are also obligations on the user of code (not a bad thing
in itself, although they should not be ignored and I think they are
overkill in this case).
> The only "threat" involved here is the implicit threat that failing to
> comply with the licence makes you act contrarily to the intentions of
> the copyright holder.
It makes your act illegal. Using GNU software illegally (say by
releasing a public domain program that uses some GNU code) is like say
stealing a car, something few people would do. (Software theft is
arguably less risky in practice though.)
> You encounter this threat almost always when buying books,
> records, software
Indeed.
> Your "appealing to civic sense" seems to mean putting it in the
> public domain and asking people to please feel bad about it
You don't even need to ask. You can just hope people will contribute in
a sensible way (publishing improvements, not selling things without
adding value to naive punters, &c). In a well working society, they
will.
In any case, whatever the licensing, most people never contribute
anything, and people who do make contributions will still make them
anyway. So the legal noise is rather useless, and can push honest people
to reinvent the wheel uselessly (thus spending the time they could have
used contributing new free software to rewrite GPLed software...).
> But for "stand-alone" applications, the GPL is certainly not
> restricting the customer in serious ways.
The thread started on libraries. If you want to use a piece of a
stand-alone application under different conditions, you have to look
elsewhere.
The biggest problem I find with the GNU licence is that it is so poorly
understood. People do GPL software without understanding the
restrictions, simply because GNU is famous &c. If people used the GPL
fully understanding it, I would have no objection (apart from finding it
slightly counter-productive, but that's their choice as you said).
David Kastrup
Franck Arnaud <Franck...@stratus.com> writes:
> David Kastrup:
>
> > Nobody forces you to use GNU software.
>
> Yes, a bit like nobody forces anyone to use Microsoft software. In
> practice, it's hard (or very expensive) to use Unix without using GNU
> software. Unix is useful to a lot of people, who more or less have
> practically no choice but to use GNU software.
You have deleted the passage where I explained what "use" of GPLed
software is governed by the GPL restriction. Just calling the program
is allowed usage. Changing the program and compiling it is allowed
usage. Using that executable for whatever purpose is allowed usage.
Redistribution without putting the whole under the same licence is
*not* allowed.
So you're not complaining that you cannot "use" the software in the
way you use Microsoft software (namely being allowed to call it). You
are complaining that you might not start making derived works from it
and redistribute these derived works under different conditions.
This is an entirely different ballpark, and muddling these
distinctions and warning people off "using" GPLed software rather than
Microsoft software because it "restricts" you is absolute folly.
> > There are no legal threats involved at all. All that the GPL defines
> > is what *rights* are given to a user of the software.
>
> Yes, but there are also obligations on the user of code (not a bad thing
> in itself, although they should not be ignored and I think they are
> overkill in this case).
Only if by "user of code" you mean somebody which actually takes the
source code, cuts snippets from it, and uses them for a program of his
own.
> > The only "threat" involved here is the implicit threat that failing to
> > comply with the licence makes you act contrarily to the intentions of
> > the copyright holder.
>
> It makes your act illegal. Using GNU software illegally (say by
> releasing a public domain program that uses some GNU code) is like say
> stealing a car, something few people would do. (Software theft is
> arguably less risky in practice though.)
Right. Your point?
> You don't even need to ask. You can just hope people will contribute in
> a sensible way (publishing improvements, not selling things without
> adding value to naive punters, &c). In a well working society, they
> will.
In a "well working society", socialism will be the optimal system.
Unfortunately, it turns out if people are left entirely to their own
devices, they do not always choose to behave in ways that are optimal
for the thriving of society. Putting some generally accepted barrier
against the most blatant abuses turns out to be not the worst idea.
The GPL tries to do that.
> In any case, whatever the licensing, most people never contribute
> anything, and people who do make contributions will still make them
> anyway. So the legal noise is rather useless, and can push honest people
> to reinvent the wheel uselessly (thus spending the time they could have
> used contributing new free software to rewrite GPLed software...).
The GPL tries to inhibit things like, say, some commercial outlet
finding and fixing some crucial bugs in gcc, then selling "Bugbrat
gcc" with a restrictive license for $5000. People will have to buy
that because the bug fixes will only be available to Bugbrat clients,
although most of the work was effectively stolen from the FSF. It is
a good thing the GPL does not permit this sort of thing which
ultimately ends in several commercially available versions none of
which is free of *all* bugs and an even bugguer free version.
> The biggest problem I find with the GNU licence is that it is so poorly
> understood. People do GPL software without understanding the
> restrictions, simply because GNU is famous &c. If people used the GPL
> fully understanding it, I would have no objection (apart from finding it
> slightly counter-productive, but that's their choice as you said).
Well, some people also use it because they think a licence which has
brought an entirely free operating system with a vast range of
utilities available for it probably is not inherently bad. To support
a code basis which has given them so much to do with is not a bad
motivation, IMHO.
AFAIK, this has been one major reason for the Linux kernel (and later
a lot of other system components apart from the already existing GNU
components under GPL anyway) being put under GPL.
And a good reason, if you ask me.
Alan Morgan
In article <341FE7...@stratus.com>,
Franck Arnaud <Franck...@stratus.com> wrote:
>David Kastrup:
>
>> Nobody forces you to use GNU software.
>
>Yes, a bit like nobody forces anyone to use Microsoft software. In
>practice, it's hard (or very expensive) to use Unix without using GNU
>software.
Huh? What planet are you from? I would guess that the most widely
used bits of GNU software are emacs and gcc. If you use your
system's compiler and vi as a text editor it is *easy* to spend your
whole life working on Unix and never come into contact with GNU
software.
I conceed that it is very difficult to use *Linux* and not use GNU
software, but that is a different matter.
Alan
Joerg Rodemann
Bertrand Meyer (Bertran...@eiffel.com) wrote:
> As far as I understand the discussion, the problem will not
> arise for Eiffel. The language is designed so that the code of
> generic classes need not be duplicated for different
> "generic derivations" of the same generic class
> (i.e. different types obtained by providing different generic
> parameters, as in LIST [BOAT] and LIST [PERSON]).
> Our implementation, and I believe others too, indeed do not
> duplicate the code in such cases. Nor is there any need to
> "copy the code into your program".
Well, sorry to raise this topic again, we had a long discussion about that
shortly and it's still continuing, but this seems to point to some problems
we discussed in a concrete situation: how is the Eiffel system going to check
the usage of a class versus its specification (seems we agreed on the term
short-flat form as a similar concept to the Ada spec.) Is the Eiffel system
able to check against the compiled library or is it more likely to leave that
to the linker as in C++? (Sure, you can check against header files there, but
who tells you they are correct, until you link it into an executable?)
Is this a problem and a point for separated interface/implementation way?
Or is there a simple solution? If so how does it work? Certainly you would
not like to include the complete library source, would you?
> (Please note that this observation includes no criticism or even
> mention of Ada; its intention is simply, since Robert Dewar's
> message was cross-posted to comp.lang.eiffel, to address his
> point insofar as they apply to Eiffel.)
> More generally I think that the idea of adapting the Gnu
> Public License to cover reusable O-O components is excellent.
Agreed: the time is ripe to think about reusing in a larger way. And I would
like to see a much better interoperability between OO-languages as well.
Regards
Joerg
--
rode...@mathematik.uni-ulm.de | Dipl.-Phys. Joerg S. Rodemann
Phone: ++49-(0)711-5090670 | Flurstrasse 21, D-70372 Stuttgart, Germany
-------------------------------+---------------------------------------------
rode...@rus.uni-stuttgart.de | University of Stuttgart, Computing Center
Phone: ++49-(0)711-685-5815 | Visualization Department, Office: 0.304
Fax: ++49-(0)711-678-7626 | Allmandring 30a, D-70550 Stuttgart, Germany
James Youngman
>>>>> "Franck" == Franck Arnaud <Franck...@stratus.com> writes:
Franck> It makes your act illegal. Using GNU software illegally (say
Franck> by releasing a public domain program that uses some GNU
Franck> code) is like say stealing a car, something few people would
Franck> do. (Software theft is arguably less risky in practice
Franck> though.)
That's not _using_ the GNU software. That is creating and
DISTRIBUTING a derived work, something which is usually completely
forbidden (or, rather, not allowed) under most copyright licenses.
The USE of GNU programs is completely unrestricted. It is only the
acts of modifying and copying the GPLed work that are restricted.
That goes further than mere "use".
Franck> The biggest problem I find with the GNU licence is that it
Franck> is so poorly understood. People do GPL software without
Franck> understanding the restrictions, simply because GNU is famous
Franck> &c. If people used the GPL fully understanding it, I would
Franck> have no objection (apart from finding it slightly
Franck> counter-productive, but that's their choice as you said).
Well, the only solution is for people to read it.
Robert Dewar
Bertrand said
<<As far as I understand the discussion, the problem will not
arise for Eiffel. The language is designed so that the code of
generic classes need not be duplicated for different
"generic derivations" of the same generic class
(i.e. different types obtained by providing different generic
parameters, as in LIST [BOAT] and LIST [PERSON]).
Our implementation, and I believe others too, indeed do not
duplicate the code in such cases. Nor is there any need to
"copy the code into your program".>>
Right, this kind of genericity is easily achieved with shared code. Of course
Ada genericity is quite a bit more extensive, and for example, even in the
simple case of a generic instantiated with two different floating-point
precisions, the only path to efficient code is duplication.
This is ONLY an efficiency issue, there is nothing in Ada which requires
code duplication. Some compilers use macro substitution always, some use
shared code always, some pick and choose, are the user can control which.
Robert Dewar
Bertrand said
<<As far as I understand the discussion, the problem will not
arise for Eiffel. The language is designed so that the code of
generic classes need not be duplicated for different
"generic derivations" of the same generic class
(i.e. different types obtained by providing different generic
parameters, as in LIST [BOAT] and LIST [PERSON]).
Our implementation, and I believe others too, indeed do not
duplicate the code in such cases. Nor is there any need to
"copy the code into your program".>>
I assume though that a good Eiffel compiler can most certainly inline
procedure bodies across file boundaries (or at least that the language
does not preclude this optimization), and this generates the same kind
of GPL licensing concerns as generic instantiation by copying (which is
after all just a form of inlining).
Joachim Durchholz
Franck Arnaud wrote:
> [GPL] It's a rather condescending approach, relying on some form of
> legal
> threat (using the law to enforce an ideology). Personally I prefer
> approaches that rely on people's civic sense rather than bullying.
Well, I don't have a problem with that. People's civic sense rapidly
disintegrates as soon as real money is involved. Legal stuff is the
*only* way to make sure anybody behaves, sad as this is.
Regards,
Joachim
--
Please don't send unsolicited ads.
David Kastrup
Joachim Durchholz <joachim....@munich.netsurf.de> writes:
> Franck Arnaud wrote:
> > [GPL] It's a rather condescending approach, relying on some form of
> > legal
> > threat (using the law to enforce an ideology). Personally I prefer
> > approaches that rely on people's civic sense rather than bullying.
>
> Well, I don't have a problem with that. People's civic sense rapidly
> disintegrates as soon as real money is involved. Legal stuff is the
> *only* way to make sure anybody behaves, sad as this is.
This is particularly true when we are talking about the corporate
world. Would you want to force a programmer to say to his management:
"Well, we could save 6 months of development if we just took that code
from so-and-so. The licence does not prohibit that, but we are
supposed to feel bad about it if we do and we would not want that, do
we?"
Or would you have the "civic sense" endowed programmer hide this
option to management and risk being fired if they find out that he
wilfully withheld information legally worth six manmonths to them?
It is a bad idea to waffle about civic sense and "but you rather
should" and "I'd like you to". That way the people with less "civic
sense" get the best use from your software. Is that what you want to
support?
If not, then make a clear legal statement. Put your software under a
licence permitting certain things and prohibiting others, or release
it entirely unconstrained as public domain.
But don't make a half-baked muddle of it where everybody has to decide
on his own what he might be doing with your software.