Powered by

Considerations For FLOSS Hackers About Oracle vs. Google

Monday 16 August 2010 by Bradley M. Kuhn

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.

[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'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.

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.

Both previously and presently, I have been employed by and/or done work for various organizations that also have views on Free, Libre, and Open Source Software. As should be blatantly obvious, this is my website, not theirs, so please do not assume views and opinions here belong to any such organization. Since I do co-own ebb.org with my wife, it may not be so obvious that these aren't her views and opinions, either.