Personal tools

Microsoft's Empty Promise

by
brett
Contributions
—
Published on
Jul 16, 2009 06:06 PM

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...?

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.

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.