-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Microsoft's Empty Promise
Last week, Microsoft extended the terms of their Community Promise to
implementations of the ECMA 334 and 335 standards. You might think this means
it's safe to write your software in C#. However, this promise is full of
loopholes, and it's nowhere near enough to make C# safe.
Why Worry About C#?
Since we published Richard's article about Mono last week, some people have
been asking us why we're expressing special concern about free software
developers relying on C# and Mono, instead of other languages. Sun probably
has patents that cover Java. Maybe IBM has patents that cover C
compilers. "Shouldn't we discourage the use of these too?" they ask.
It's true that all software patents are a threat to developers—but that doesn't
mean that all software patents are equally threatening. Different companies
might have patents that could be used to attack other languages, but if we
worried about every patent that could be used against us, we wouldn't get
anything done. Microsoft's patents are much more dangerous: it's the only
major software company that has declared itself the enemy of GNU/Linux and
stated its intention to attack our community with patents. If Microsoft
designed a patent trap into C#, that is no more than what it said it would do.
The company has been quite clear about its intentions since late 2006. At a
user conference in November that year, Microsoft CEO Steve Ballmer said,
responding to a question about their patent agreement with Novell:
... the fact that [GNU/Linux] uses our patented intellectual property [sic]
is a problem for our shareholders. We spend $7 billion a year on R&D, our
shareholders expect us to protect or license or get economic benefit from our
patented innovations. So how do we somehow get the appropriate economic return
for our patented innovation...?
(Seattle Post-Intellegencer, The Microsoft Blog, "Ballmer on Novell, Linux and
patents," November 16, 2006.)
A few days later, an interview with Microsoft President Bob Muglia was
published, and he made it clear that they considered C# one of these
so-called "patented innovations:"
There is a substantive effort in open source [sic] to bring such an
implementation of .Net to market, known as Mono and being driven by Novell,
and one of the attributes of the agreement we made with Novell is that the
intellectual property [sic] associated with that is available to Novell
customers.
(eWeek.com, "Microsofts Muglia Talks Longhorn, Novell and Java", November 17,
2006.)
They've been turning up the heat ever since. In May 2007, Microsoft followed
all this up by announcing in a Fortune magazine interview that they believed
GNU/Linux infringed 235 Microsoft patents. And recently they made it very
clear that these were not idle threats: the company sued TomTom for using the
VFAT filesystem implementation in the kernel Linux without buying a license
from it.
All of this can't simply be brushed aside. These are statements and actions
made at the highest executive levels of the company. Using patents to divide
and conquer the free software community is a fundamental part of their
corporate strategy. Because of that, C# represents a unique threat to us. The
language was developed inside Microsoft, so it's likely they have many patents
to cover different aspects of its implementation. That would make free
software implementations of C#, like Mono, an easy target for attack.
The Community Promise does nothing to change any of this. Microsoft had an
opportunity to take action and demonstrate that it meant us no harm with C#.
Instead, they took meaningless half-measures that leave them with plenty of
opportunities to hurt us.
Incomplete Standards
The ECMA 334 and 335 specifications describe the core C# language, including
information about standard libraries that must be available in any compliant
implementation. However, there are several libraries that are included with
Mono, and commonly used by applications like Tomboy, that are not required by
the standard. And just to be clear, we're not talking about Windows-specific
libraries like ASP.NET and Windows Forms. Instead, we're talking about
libraries under the System namespace that provide common functionality
programmers expect in modern programming languages: binary object
serialization, regular expressions, XPath and XSLT, and more.
Because these libraries are not defined in the ECMA specifications, they are
not protected in any way by Microsoft's Community Promise. If this were the
only problem with the promise, it might be safe to use applications that avoid
these libraries, and stick to what's in the standard. But even the code that's
covered by the promise isn't completely safe.
Figuring Out What's Necessary
The Community Promise only extends to claims in Microsoft patents that are
necessary to implement the covered specifications. Judging just by the size of
its patent portfolio, it's likely that Microsoft holds patents which a
complete standard implementation probably infringes even if it's not strictly
necessary—maybe the patent covers a straightforward speed optimization, or
some common way of performing some task. The Community Promise doesn't say
anything about these patents, and so Microsoft can still use them to threaten
standard implementations.
Moving the Goalposts
Let's say you've written an implementation of one of the specifications covered
by the Community Promise, and you want to determine whether or not you'll be
sued for infringing a certain Microsoft patent. The necessity question already
makes it difficult enough to figure this out. But even if you manage it, you
should make sure you check again tomorrow, because the Community Promise might
not protect you then.
The Community Promise does not give you any rights to exercise the patented
claims. It only says that Microsoft will not sue you over claims in patents
that it owns or controls. If Microsoft sells one of those patents, there's
nothing stopping the buyer from suing everyone who uses the software.
The Solution: A Comprehensive Patent License
If Microsoft genuinely wants to reassure free software users that it does not
intend to sue them for using Mono, it should grant the public an irrevocable
patent license for all of its patents that Mono actually exercises. That would
neatly avoid all of the existing problems with the Community Promise: it's
broad enough in scope that we don't have to figure out what's covered by the
specification or strictly necessary to implement it. And it would still be in
force even if Microsoft sold the patents.
This isn't an unreasonable request, either. GPLv3 requires distributors to
provide a similar license when they convey modified versions of covered
software, and plenty of companies large and small have had no problem doing
that. Certainly one with Microsoft's resources should be able to manage this,
too. If they're unsure how to go about it, they should get in touch with us;
we'd be happy to work with them to make sure it's satisfactory.
Until that happens, free software developers still should not write software
that depends on Mono. C# implementations can still be attacked by Microsoft's
patents: the Community Promise is designed to give the company several outs if
it wants them. We don't want to see developers' hard work lost to the
community if we lose the ability to use Mono, and until we eliminate software
patents altogether, using another language is the best way to prevent that
from happening.
_______________
Copyright © 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Privacy Policy.
Verbatim copying and distribution of this entire article are permitted
worldwide, without royalty, in any medium, provided this notice is preserved.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)
iEYEARECAAYFAkpgisUACgkQU4xAY3RXLo6kkwCglEF0kx+kwayBKHS9bloAWH1L
cyAAoIPHQb7UUarjYTGWlZ8qLPhAH30d
=Q6oo
-----END PGP SIGNATURE-----
|
|
