APSL 1.1 available for comment.

[Brian Behlendorf]

On Mon, 19 Apr 1999, Ken Arromdee wrote:
> The revised version now adds to the withdrawal clause saying that once a claim
> of infringement is decided by a court, Apple has to un-withdraw the rights if
> possible.

When citing from the document, it's useful to provide the precise section
numbers you're talking about.  This is clearly 9.1, it just took some time
to find it.

> At first glance this seems to alleviate the problems people have with Apple's
> right to withdraw the license.  But it doesn't.  The only kind of claim that
> is required is a claim.  It doesn't have to be a valid claim, or a legal claim,
> and it doesn't have to be a claim that was taken to court at all--the hot dog
> vendor on the street corner can claim infringement and if the claim never goes
> to court, Apple can still withdraw the license for all eternity.

First, Apple can't withdraw the license, they can only withdraw code that
matches section 1.1: "only those specific portions of Original Code that
allegedly infringe upon any party's intellectual property rights or are
otherwise the subject of a claim of infringement."

Second, does the license need to define "claim" as "claim filed in a court
of law", or is that obvious from the wording?  Clearly, if Joe the hot dog
vendor did stand on the street and claim Apple was violating its patents
on cooking hot dogs, Apple could ignore it (and so could you) until it was
filed.  And if Joe really did have a legal claim, but Apple was able to
horse-trade patent licenses with him and keep it from going to trial, then
the closure of the claim would seem to also be a "determination".

This seems to be about as good as Apple can do to address the patent
issue, one which is lying dormant in licenses that don't address them.
The big legal fear to face here is "contributory infringement", and with
these clauses Apple is doing all it can to shield itself from any
liability along those lines.  

Let me put it in more real terms.  Let's say there's a patent on the
pool-based memory allocation scheme Apache uses (unlikely, but let's say).
The patent holder realizes this, and, being an asshole with a need for
cash, demands a $10 per copy royalty on the use of his patents.  He can't
go after each individual user (maybe he could go after IBM and C2Net and
other commercial Apache vendors) but he decides to go after the source -
the Apache developers - and if they don't cough up $10 for every copy used
out there, he sues for contributory infringement.  The best we could do is
turn off the download area for the software until we've had a chance to
fix that code and release a new version.  But under patent law, as I
understand it, that's not good enough - we have to expend some sort of
reasonable effort to get people to STOP using the old, infringing version.
What "reasonable effort" means for us is probably different (from a
court's point of view) than what it means for a company like Apple, with
deep pockets.  

You may feel that "contributory infringement" is not worth worrying much
about - reasonable minds (including those of lawyers, apparently) may
disagree.  But it is a lawyer's job to be paranoid, after all.

But it sounds like you have another suspicion - that Apple will use this
license as a ruse to obtain some good code, which they will then in effect
turn proprietary and close the project down, and deny the right to
derivative works that could allow this code to have a life
post-Apple-involvement.  That would require some pretty outlandish things,
like Apple claiming that the entire code base violates a particular patent
claim, something that could be demonstrably proven false, probably even in
court. The new language in 1.1 appears to go pretty far towards making
even more explicit what Apple's options are in the event of a patent
claim, and they all appear to be in the developers' interests.  Note the
section:

  nothing in this License shall be
  construed to restrict You, at Your option and subject to applicable law,
  from replacing the Affected Original Code with non-infringing code or
  independently negotiating for necessary rights from such third party.

Let's take another example - let's say there's a tree of code in an
APSL-licensed project which gets very little use, was experimental, etc...
let's say Apple themselves aren't using it, but there is a small group of
people who are.  Let's say a patent claim is filed against something in
that section of code; should Apple have to spend the money to address the
claim?  Their "withdrawal" of the code simply says they won't expend
effort to defend it against patent claims, and thus won't release it
anymore; but if another individual or group decides they still want it,
they can negotiate with the patent holder for the right to
use/copy/modify, etc.

> It also raises the problem (first raised in connection with the export clause)
> of what happens to people in foreign countries.  

Section 13.7.  US Law applies.

> If, say, the software is
> claimed to infringe someone's patent, but a person is in a foreign country
> that does not recognize software patents, Apple can use the withdrawal clause
> and restrict that person's use of the software anyway.

It seems to me section 9.1 already addresses that - "independently
negotiating for necessary rights".  If there are no rights that need
negotiating, then the withdrawal doesn't apply to you, does it?

> (The section of the Open Source definition these violate, of course, is the
> one about free redistribution.)

Remember that a license is the "source code" to the relationship between
you and the licensor.  There is another relationship involved here
sometimes, and that is the relationship between a patent holder and each
of the other two parties.  It seems to me that the language you find
objectionable is language necessary to help protect Apple from the patent
holder.  There is no language that could be provided in a license that
shields you, the licensee, from the patent holder without violating US
law.


I think a lot of issues around the patent problems can be summed up this
way: what developers want, and what they (incorrectly) think they have
under other licenses, is code that is patent-free.  Sorry, it doesn't work
like that; any software, under any license, can come under a claim of
patent infringement by a patent holder, at which point it is incumbent on 
the infringing entity (anyone the patent holder chooses to sue - and
unlike trademarks, patents don't go away if you selectively enforce them) 
to stop infringing, and do what they can to prevent others whom they
enabled to infringe to stop infringing as well. If you don't like that
situation, there are three things you can do:

  a) Lobby the USPTO (or your representatives in Congress, if you're in
the US) to create a "patent clearing" service, where you can submit code
for a fee and have it either declared "patent-immune", meaning no patent
claim may be applied to it, or be given a list of patents which it may
infringe.  Of course, the USPTO is likely to not want to do something like
this, because then the liability for an incorrect assessment will be on
them.

  b) Lobby Congress to reduce the length of time alloted for patents on
software algorithms from 17 years to something more reasonable for this
industry, like 4.  Or pick your favorite number.  17 is just insane, I
think we can all agree.

  c) Create a patent clearinghouse project, so you can cross-license 
patents with patent holders, e.g. "let us use yours and you can use ours".
There are a couple projects like this, I think - I'm sure someone else has
URL's.



I'm also not a lawyer, nor speaking for OSI, just my own opinions and
unmitigated hearsay.

	Brian