Savannah rejects a project because it uses GPL

[Bernhard R. Link]

* Alfred M. Szmidt <ams at gnu.org> [060213 21:27]:
> FDL licensed documentation isn't non-free software, it isn't even free
> software.  It is documentation.

Here we differ. There are just different definitions of what
software means. But this does not change the fact that freedom matters.
There are of course different forms of freedom needed for different
things. 
For things like (printed) books I think those freedoms the FDL offers
are quite good, also a bit annoying, as those cover and back texts
have no sensible restriction on their content and cannot be removed
if they get absurd. But alas, publishers may be hard to pressured to
publish anything free (I don't know, as I never tried), and we accept
many restrictions to our freedoms for some gains, so (printed) books
are perhaps still good if they do not offer all those freedoms
we mean when we speak about "free software".
I hope all participants in this discussion agree that those freedoms 
we associate with the words "free software" are needed for computer
programs (as we are playing word games here, I better write "computer
programs" before we end at theatre or TV schedules). Motives may differ,
I think it is immoral to force people to cope with buggy programs or
simply programs doing something different than they want with the
ability but not the legal freedom to change this. And even worse
than forbidding people to help themselves it to forbid them to help
others.
Now, what do those programs running my computer consist of? There are
of course statements meant for a compiler or interpreter, but there
is more: there are variable names and comments between them.
Now variable names we better forget and look at comments, they are
clearly documentation in every sense I can think of. (Unless they
are false, then someone might argue they are no documentation, but
let's not dive into that). While there is some easy way to say which
parts cause the compiler to do things and which do not, that does not
mean the source (in the sense of "preferred form of modification") is
only the parts that do. A comment may describe an algorithm in
such a form someone may throw away the implementation and just
translate the description again to code. While copyright laws do only
cover expression and not the ideas behind it, most such "translations"
will have more of renarrations than of translations, but only if you
no longer count any pseudocodes as the "documentation licensed" part.
Or at least not those forms of pseudocode in the documentation that
are more speech than pseudocode (Good finding any criterium for
separating). And then there are not only compilers, but interpreters,
where you may have restrictions on the size. You might want to remove
all comments (and all invariant secions those documentation contained,
as we all know, documentation does not need the same freedoms, *cough*)
to put it on some bootfloppy. Well, all comments except that one
descriping the boot parameters people may need there. So do I have to
rewrite that comment under a free license?
This leads me to believe that those parts of the documentation are part
of the source of the program. (And are both software (or if you prefer
to call other things software, let's call it "things we want the
full freedoms of free software for") and documentation).

But software is not only the source code with its comments, it need
more things to work (even though one may say those things are not part 
of the software, as it is no program and thus not software by some
definitions): one needs labels for some ui elements, catalogs with
translations of those, if it is a gui also icons, contents of help-
tags popping up, perhaps even some animations showing what the program
does. Those form a integral part of the program, and being able to
change the program logics but not those ui elements is annoying,
as if forcing to separate them, as some variant may want to embed
the icons or help texts within the source. Thus those things should
clearly have all the freedoms attached to them the program code has.

Let's look from the other side. Common (well, still quite common,
call me a bit old fashioned if you like) forms to write documentation
are systems hardly to distinguish from programing languages by people
grown up with "ms word". While I personally seldom write in postscript
due to its lack for German umlauts, I regulary use groff or LateX,
with non-trivial formatting "programs" in them, sometimes separated
in a good semantic mark-up style, sometimes tightly interwoven with
the actual texts. Do those formatting/text-processing programs
within the documentation's source need different freedoms than other
programs?

So there is documentation within programs, and there are programs
within documentation, and many things hard to distinguish. And many
things shifting between those. Take a documentation of some interface,
add some machine parsable tags to generate headers file from it, which
freedoms do you need? (There are some claims that there are even FSF
projects generating some GPLed headers from FDLed documentation
currently floating around, but if those aren't why shouldn't someone
else want to add something like that?).

So there are many reasons to not make a distinguish between all those
bits contained in an OS by some undefinable criterias wheather they
cause the creation of something the CPU interprets (machine code)
or to be interpreted by something interpreted by the CPU (scripts)
one the one side, and things interpreted by something interpreted by the
CPU (images, texts, ...).

Looking at different definitions of software, many older ones are things
like old WordNet definition:
        
n : (computer science) written programs or procedures or rules
    and associated documentation pertaining to the
    operation of a computer system and that are stored in
    read/write memory

That is of course an old definition. An pressed CD can still contain
software, though it is not writeable in any sense. Although many
people today believe the documentation is not part of the software.
But I think this is mostly caused by the bad habit of propietary
program distribution without source, as I tried to describe above that
source and documentation are some entity, and if you are a mere consumer
without the potential to construct, program and documentation tend to
be seen as seperate entitites.

But even if you prefer to not call anything that is documentation
software, all the things stored on computers to make them operate
and to make humans able to operate them, should be free. And not
only some reduced "I do not want to do this, so noone else should
want to do this" freedom, but the same full freedom free software
needs, weather you call that free software, free creamware, or
free "things stored somewhere in bits"ware.


> Nor is FDL-licensed documentation removed, it is _moved_ to the
> non-free section.  Which is part of Debian, desite whatever claims
> people will make.

Well, here we come back to names and definitions. The Debian project
are many people, which non-free stuff is clearly not part. The
Debian OS or Debian Distribution consists (with some exceptions,
like some things overlooked, some stuff slipped in and not yet
thrown out in the hope it might be relicensed) only out of free
software. (And the Debian OS and Debian Distribution and Debian
Release are clearly words Debian is up to define).
Thus the "Debian" you refer to, which has non-free parts can only
be something like "those things the Debian project maintains" or
"those things mirrors put in the debian/" or "software some people
refer to when they talk about Debian". In those meanings your
sentence would be correct.
But Debian does not promise those will be free, but that it will
create a 100% free operating system, which it really tries.
(Though of course fails, like the Gnu FDL stuff slipped in, and I
 am sure in those thousends plenty of programs with some non-free
 parts slipped in could be found by some omniscient being,
 as erring is human, and before the GNU project changes this many
 people did not care much for licenses).
Of course the Debian Project also maintains some additional set
of packages, in addition to the self-contained free Debian Operating
System, which are either not free enough by our guidelines (non-free)
or depend on something of this kind (contrib). Those sections are 
clearly marked as such, need additional manual intervention to even
be visible to the package installers and reside in clearly
named directories on the mirrors.

This acknoledges that world is not perfect. That while 100% free 
software is important, some people have to make compromises to
get as much free software as possible. Some not-so-evil things
like povray, which is mostly only too old to have a free license
or to easily change to one, or documentation under FDL, which
might be the only one for some programs without which some people
might not be able to use free software. Or even worse things
like drivers needed for hardware of incoperative vendors or
even non-free software some people might not get rid of easily.

Offering some such clearly marked and separated additions to
the Debian distribution served two purposes: On the one hand it
helps people to use at much free software as possible by not
making them waste all their energy to get something working when
they are caught in without all their freedoms, so that they have
more energy trying to free themself by escaping that non-free stuff.
On the other hand it is just practical to keep the Debian promise
and the Debian distribution pure. There is no pressure to knowlingly
include or keep non-free stuff, so people do not easily get caught,
finding themselves depending on stuff they do not have allowance to
use the way they want. (Didn't that ututo-e distributed by ftp.gnu.org
not contain some non-free graphic card drivers some time ago?)

	Bernhard R. Link