[Python-mode] FSF assignment policy

Stephen J. Turnbull stephen at xemacs.org
Tue Jan 27 16:55:09 CET 2009

I am not a lawyer, and I don't speak for the FSF or the Emacs Project.
I do speak for the XEmacs Project until such time as someone feels
like complaining about it. :-)

Andreas Roehler writes:

 > as FSF assignment policy was raised again at
 > python-mode at python.org, please permit to ask you a
 > thing I never understood:
 > AFAIS every Emacs-file is inspired by many, many others
 > from the very beginning. We see almost always a plenty
 > of revisions with a lot of people involved.

AIUI, this is one of the motivations for the free software movement:
each program created is a joint creation of the apparent author(s),
and of the community around them.  (I'm pretty sure Richard would say
it's not the most important motivation, but I suppose he will
acknowledge it.)

Nevertheless, software *also* exists in a legal environment, and the
assignment policy (like the GPL) is a compromise between the *goal* of
software freedom and the *limited means* provided[1] by that legal
system for implementing software freedom.

 > So how a single developer could ever declare what the
 > assignment formula demands? How could any person
 > declare, he _owns_ the rights at the code, thus
 > assigning it.

For starters, he doesn't make such a declaration about "the" code.  He
makes that declaration about his own contribution.  The way he
acquires that power is simple: he writes some code down.  That's all
it takes!  Whether he publishes or not.  Then, according to the Berne
Convention and other applicable treaties, he is automatically awarded
such copyright privileges as are created by the law of each
jurisdiction in which the software is available.

Exactly what privileges he is awarded are determined by the local
laws, and which parts of the software are "his" are determined in
principle by the law, and in practice by a court if his claims are
contested.  In other words, the question you are asking is not posed
by the assignment policy, but rather by the very existence of
copyright itself.  The assignment policy, then, is one of an array of
policies (including advocacy of copyleft licenses, for example)
adopted by the free software movement to preserve software freedom, in
the context of such a legal system.

 > Isn't that assignment policy driving developers in a
 > kind of forgery? Making them false declarations,
 > thus having rights about them, being everyday able to
 > sue them for these false declarations?

No.  There is no forgery, assuming you make the claim in good faith.
You may still be liable for infringement if you are mistaken about the
extent of your rights, just as you may be liable for an automobile
accident if the car in front of you stops without warning for no
apparent reason and you run into it.

 > Or am I simply dreaming a bad dream?

There is no law in the U.S. or Japan about "making declarations", I
don't know about Europe.  That is, the fact that you assign what you
believe to be your code to another party does not increase your risk,
per se.  What matters is if you make or enable copies, or the assignee
does.  But for free software, the risk imposed by assignee-made copies
is precisely the same as the risk imposed by GPL-licensee-made copies.
In other words, if the risk involved in assigning your code bothers
you, what are you doing participating in free software at all?

However, the idemnity clause of the standard FSF assignment contract
may increase your risk, since you're required to defend the FSF as
well as yourself.  Ask a lawyer if that bothers you.

Note: I personally am not particularly a fan of the assignment policy,
though the recent trend in many projects to adopt such a policy may
force me to reconsider that position.  However, the objections you
seem to have in mind really apply to copyright itself, and the
assignment policy is just shadowing it.


[1]  Or barriers presented, if you will.

More information about the Python-mode mailing list