Powered by

Considerations on Patents that Read on Language Infrastructure

Monday 29 June 2009 by Bradley M. Kuhn

In an essay last Friday
entitled Why
free software shouldn't depend on Mono or C#, RMS argued a
key point that I agree with: the software freedom community should
minimize its use of programming language infrastructure that comes
primarily from anti-software-freedom companies, notwithstanding FaiF
(Free as in Freedom) implementations. I've been thinking about an
extension of that argument: that language infrastructure created in a
community process is likely more resilient against attacks from
proprietary software companies.

Specifically, I am considering the risk that a patent attack will occur
against the language or its canonical implementation. We know that the
USPTO appears to have no bounds in constantly granting so-called
“software patents”, most of which are invalid within their
own system, and the rest may be like
the RSA
patent, and will force our community to invent around them, or (as
we had to do with RSA), “wait them out”. I'd like to
consider how these known facts apply to the implementation of language
infrastructure in the Free Software world.

Programming languages and their associated standard libraries and
implementations evolve in three basic ways:

A Free Software community designs and implements the language in a
grassroots fashion. Perl, PHP, and Python are a few examples.

A single corporate entity controls the language and its canonical
implementation. They perhaps also convince some standards body to adopt
it, but usually retain complete control. C# and Java a few
examples.

A single corporate entity controlled the language initially, but more
than 20 years have passed and the language now has many proprietary and
Free Software implementations. C and C++ are a few examples.

The patent issues in each of these situations deserves different
consideration, primarily related to the dispersion of patents that
likely read on the given language implementation. We have to assume
that the USPTO has granted many patents that read on any software a
person can conceivably write. The question is always: of all the things
you can write, which has the most risk of patent attack from the patent
holders in question?

In the case of the community-designed and Free-Software-implemented
languages, the patent risk is likely spread across many companies, and
mitigated by the fact that few have probably filed patents applications
designed specifically to read on the language and its implementation.
Since various individuals and companies contributed to the development
and design, and because it was a process run by the community, it's
unlikely there was a master plan by one entity to apply specifically for
patents on the language. So, while there are likely many patents that
read on the implementation, a single holder is unlikely to hold all the
patents, and those patents were probably not crafted for the specific
language. Only some of these many patent-holding entities will have a
desire to attack Free Software. It is therefore less likely that a user
of the language will be sued; a patent troll would have to do some work
to acquire the relevant patent. If that unlikely event does anyway
occur, the fact that the patent was not specifically designed to read on
the language implementation may indeed help, either by easing the
process of “inventing around” or by making it more difficult
for the patent troll to show the patent reads on the language
implementation. Finally, if the implementation is under a license like
GPL, or the Apache License (or any license with a patent grant), those
companies that did contribute to the language implementation may have
granted a patent license already.

Of course, these are all relative arguments against the alternative: a
language designed by a single company. If a single corporate entity
designed and implemented the language more recently than 20 years ago,
that company likely filed many yet-unexpired patents throughout the
process of designing and implementing the language and its
infrastructure. When the Free Software community implements fresh
versions of the language from scratch, it's very likely that it will
generate software that reads on those patents. Thus, the community must
live in constant and direct fear of that company. We must assume the
patents exist, and we know who holds them, and we know they filed them
with this very language in mind. It may be tough to invent around them
and still keep the Free Software implementation compatible. This is why
I and other Free Software advocates have insisted for years the all
companies who claim to support software freedom should grant
GPL-compatible patent licenses for all their patents. (I still await
Sam Ramji's response on my call for Microsoft to do so.)

Without that explicit patent license, we certainly should prefer the
community-driven and Free-Software-developed languages over those
developed by companies (like Microsoft) that have a history of anti-Free
Software practices. Regarding companies with a more ambiguous history
toward Free Software, some might argue that patents consolidated in a
“friendly” company is safest of all alternatives. They
might argue that with all those patents consolidated, 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.
While I think it's more likely that Microsoft will attack FaiF C#
implementations with its patents eventually, an Oracle attack on FaiF
Java is a possibility. (We should also not forget that Sun in the late
1990s was very opposed to Free Software implementations of Java; the
corporate winds always change and we should not throw ourselves to
them.)

The last case in my list deserves at least a brief mention. Languages
like C (which was a purely AT&T endeavor initially) have reached the
age that the early patents would have now expired, and such languages
have slowly moved into community and standards-driven control. Thus,
over long periods of time, history shows us that companies do loosen
their iron grip of proprietary control of language implementations.
However, during that first 20 year period, we should face them with
great trepidation and stick with languages developed by the Free
Software community itself.

Finally, I close with important advice: don't be paralyzed with fear
over software patents. There are likely some USA patents that read on
any software you write. Make good choices (like avoiding C#, as RMS
suggests, and favoring languages like Perl, Python, PHP and C), and get
on with your work. If, as a non-profit Free Software developer, someone
writes you a threatening letter about patents or sues you for patent
infringement, of course seek help from an attorney.

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.