Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2010/08/16/oracle-google.html
Many have already opined about the Oracle v. Google lawsuit filed last
week. As you might expect, I’m not that worried about what company sues
what company for some heap of cash; those sort of for-profit wranglings
just aren’t what concerns me. Rather, I’m focused on what this event
means for the future of software freedom. And, I think even at this
early stage of the lawsuit, there are already a few lessons for the Free
Software community to learn.
Avoid Single-Company-Controlled Language Infrastructure
Fourteen months ago, before the Oracle purchase of Sun,
I wrote
about the specific danger of language infrastructure developed by a
single for-profit patent-holding entity (when such infrastructure is
less than 20 years old). In that blog post, I wrote:
[Some] might argue that with all those patents consolidated [in a single
company], patent trolls will have a tough time acquiring patents and
attacking FaiF
implementations. However, while this can sometimes be temporarily true,
one cannot rely on this safety. Java, for example, is in a precarious
situation now. Oracle is not a friend to Free Software, and soon will
hold all Sun’s Java patents — a looming threat to FaiF Java
implementations … [A]n Oracle attack on FaiF Java is a possibility.
I’m sorry that I was right about this, but we should now finally learn
the lesson: languages like Java and C# are dangerous. Single companies
developed them, and there are live, unexpired patents that can easily be
used in a group to attack FaiF implementations. Of course, that doesn’t
mean other language infrastructures are completely safe from patents,
but I believe there is greater relative risk of a system with patent
consolidation at a single company.
It also bears repeating the point I made
on Linux
Outlaws last July: this doesn’t mean the Free Software community
shouldn’t have FaiF implementations of all languages. In fact,
we absolutely should, because we do want developers who are
familiar with those languages to bring their software over to GNU/Linux
and other Free Software systems.
However, this lawsuit proves that choosing some languages for newly
written Free Software is dangerous and should be avoided, especially
when there are safer choices like C, C++, Python, and Perl0. (See
my blog
post from last year for more on this subject.)
Never Let Your Company File for Patents on Your Work
James Gosling is usually
pretty cryptic in his non-technical writing, but I think if you read
carefully, it seems to me
that Gosling
regrets that Oracle now holds his patents on Java. I know developers
get nice bonuses if they let their company apply for patents on their
work. I also know there’s pressure in most large companies to get more
patents. We, as developers, must simply refuse this. We invent
this stuff, not the suits and the lawyers who want to exploit our work for
larger and larger profits. As a community of developers and computer
scientists, we must simply refuse to ever let someone patent our work. In
a phrase: just say no.
Even if you like your company today, you never know who will own those
software patents later. I’m sure James Gosling originally never
considered the idea that a company as revolting as Oracle would have
control of everything he’s invented for the last two decades. But they
do, and there’s nothing Gosling can do about what’s done with his work
and “inventions”. Learn from this example; don’t let your
company patent your work. Instead, publish online to establish prior
art as quickly as possible.
Google Is Not Merely a Pure Free Software Distributor
Google
has worked hard to cast themselves as innocent,
Free-Software-producing victims. That’s good PR because it’s true, but
it’s also not telling the whole
truth. Google
worked hard to make sure Android was completely Apache-2.0 (or even more
permissively) licensed (except for Linux, of course). There was
already plenty
Java stuff
available under the GPL that Google could have used. Sadly, Google was
so allergic to GPL for Android/Linux that they even avoided LGPL’d
components like uClibc
and glibc (in favor of
their own
permissively-licensed C library based on a BSD version).
Google’s reason for permissive-only licensing for “everything but
the kernel” was likely a classic “adoption is more important
than software freedom” scenario. Google wants Android/Linux in as
many phones as possible, and wants to eliminate any
“barrier” to such adoption, even if such a
“barrier” would defend software freedom.
This new lawsuit would be much more interesting if Google had chosen
GPL and/or LGPL for Android. In fact, if I fantasize about being
empowered to design a binding, non-financial settlement to the lawsuit,
the first item on my list would be a relicense of all future
Android/Linux systems under GPL and/or LGPL. (Basically, Google would
license only enough under LGPL to allow proprietary applications, and
license all the rest as GPL, thus yielding the same licensing
consequences as GNU/Linux and GNOME). Then, I’d have Oracle explicitly
license all its patents under GPL and/or LGPL
compatible licenses that would permit Android/Linux to continue
unencumbered, but under
copyleft. (BTW, Mark
Wielaard has a blog post that discussed more about the issue of
GPL’d/LGPL’d Java implementations and how they relate to this
lawsuit.)
I realize that’s never going to happen, but it’s an interesting thought
experiment. I am of course opposed to software patents, and I certainly
oppose companies like Oracle that produce almost all proprietary
software. However, I can at least understand the logic of Oracle not
wanting its software patents exercised in proprietary software. I think
a trade off, whereby all software patents are licensed freely and
royalty-free only for use in copylefted software is a reasonable
compromise. OTOH, knowing Oracle, they could easily have plans to
attack copyleft implementations too. Thus, we must assume they won’t
accept this reasonable compromise of “royalty-free licensing for
copyleft only”. That brings me to my next point of FaiF hackers’
concern about this lawsuit.
Never Trust a Mere Patent Promise; Demand Real Patent Licenses
I wrote after Bilski
that patent
promises just aren’t enough, and this lawsuit is an example of why.
I presume that Oracle’s lawyers have looked carefully as the various
promises and assurances that Sun made about its Java patents and have
concluded Oracle has good arguments for why those promises don’t apply
to Android. I have no idea what those arguments are, but rarely do
lawyers file a lawsuit without very good arguments already prepared. I
hope Oracle’s lawyers’ arguments are wrong and they lose. But, the fact
that Oracle even has a credible argument that Android/Linux doesn’t
already have a patent license shows again that patent promises are just
not enough.
Miguel de Icaza
used this
opportunity to point out how the Microsoft C# promises are
“better” by comparison, in his opinion.
But, Brett Smith at
FSF already found huge holes in those Microsoft promises that haven’t
been fixed. In fact, any company making these promises always tries
to hide as much nasty stuff as it can, to convince the users that they
are safe from patent aggression when they really aren’t. That’s why the
Free Software community must demand simple, clear, and permanent
royalty-free patent licenses for all patents any
company might hold. We should accept nothing less. As mentioned above,
those licenses could perhaps require that a certain Free Software
copyright license, such as GPLv3-or-later, be used for any software that
gets the advantage of the license. (i.e., I can certainly understand if
companies don’t want to accidentally grant such patent licenses to their
proprietary software competitors).
Indeed, it’s particularly important that the licenses
cover all patents and those possibly exercised in future
improvements in the software. This lawsuit has clearly shown that even
if patent pools exist for some subsets of patents for some subsets of
Free Software, patent holders will either use other patents for
aggression, or they’ll assert patents in the patent pools against Free
Software that’s not part of the pool. In essence, we must assume that
any for-profit company will become a patent troll eventually
(they always do), and therefore any cross-licensing pools that don’t
include every patent possible for any possible Free Software will always
be inadequate. So, the answer is simple: trust no
software-patent-holding company unless they give an explicit
GPLv3-compatible license for all their patents.
We Must End Software Patents
The failure of the Bilski case to end software patents in the USA means
much work lies ahead to end software patents.
The End
Software Patents Wiki has some good stuff about this case as well as
lots of other information related to software patents. There are now
heavily funded for-profit corporate efforts that seek to convince the
Free Software community
that patent
reform is enough. But, it’s not! For example, if you see
presenters at
FLOSS
conferences claiming to have solutions to patent problems, ask them if their
organization opposes all software patents, and ask them if their funders
license all their patents freely for GPLv3-or-later software
implementations. If you hear the wrong answers, then their motives and
mission are suspect.
Finally, I’d like to note that, in some sense, these patent battles
help Free Software, because it may actually teach companies that the
expense of having software patents is not worth the risk of patent
lawsuits. It’s possible we’ve reached a moment in history where it’d be
better if the Software Patent Cold War becomes a full Software Patent
Nuclear War. Software freedom can survive that “nuclear
winter”. I sometimes think that in the Free Software community,
we may find ourselves left with just two choices: fifty more years of
Patent Cold War (with lots of skirmishes like this one), or ten years of
full-on patent war (after which companies would beg Congress to end
software patents). Both outcomes are horrible until they’re resolved,
but the latter would reach resolution quicker. I often wonder which one
is the better long term for software freedom.
But, no matter what happens next, the necessary position is: all software
patents are bad for software freedom. Any entity that supports anything
short of full abolition of software patents is working against software
freedom.
0I originally had PHP listed here,
but jwildeboer
argued that Zend Technologies, Ltd. might be a problem for PHP in
the same way Oracle is for Java and Microsoft for C#. It’s true that
Zend is a software patent holder and was involved in the development
of later PHP versions. I don’t think the single-company-controlled
software patent risks with PHP are akin to those of Java and C#, since
Zend Technologies isn’t the only entity involved in PHP’s development,
but certainly the other languages listed are likely preferable to
PHP.