An Encouraging Oral Argument on Software Patents

by on February 21, 2007

I just read through this morning’s oral arguments in the case of Microsoft v. AT&T. It’s a fascinating case because it beautifully highlights the conceptual confusion that lies at the root of software patents.

The case involves a patent dispute between AT&T and Microsoft, in which AT&T claimed some Microsoft software infringed on an AT&T patent. They’ve sorted things out with regard to domestic infringement, but their dispute is over whether Microsoft is liable for infringement overseas. What happened is that Microsoft shipped a single copy of its software to an overseas distributor, who in turn installed thousands of copies of the software on overseas computers.

Under a 1984 revision to patent law, it’s patent infringement to ship the components of a patented invention overseas for the purpose of evading US patents by having the final assembly of the components occur overseas. AT&T claims that Microsoft is liable because its software was a “component” under the law. Microsoft counters that software cannot be a “component,” because it’s an abstract string of 1s and 0s. The component, they argued, was the individual copy of the software, which was created overseas.

The really illuminating thing about the oral arguments, for my money, is when the counsel for AT&T, Seth Waxman, contorts himself into pretzels trying to argue that software is more than just information:

JUSTICE BREYER: Suppose I send someone to the Patent Office, goes there, picks up the patent, and this patent is written very, very, very concretely and specifically. Gets on the phone, phones somebody in Germany and reads it to him. And that person, having an excellent memory, takes everything in and now he has the precise instruction necessary to change the machine around or put various things into it. So now it is a precise copy of the machine in the United States. Is that–how is that different from this? How is it different?

MR. WAXMAN: That is very different than this case because what–first of all, we all agree that software code in and of itself, removed from a physical structure, cannot be patentable and when software–when some–when an invention that is practiced with software is patented, at the most what you will see is preferred embodiments of the source code which is language that humans understand and which computers do not.

A lot of work has to be done in items of debugging and testing and compiling to create what is, by stipulation, at issue in this case, which is the precise, machine readable sequence that commands a computer’s CPU millions of times a second. Source code would do nothing. Source code has to be worked on overseas.

This is completely wrong. Source code is perfectly understandable to computers. Indeed, there are programs called interpreters that allow computers to directly execute programs stored in source code form. The only difference, from the computer’s perspective, is that the object code can be executed more efficiently, because it’s optimized for the native “language” of the particular processor.

But any computer can execute code written in any programming language. This is known as the Church-Turing Thesis, one of the most fundamental principles of computer science. My favorite demonstration of this fact is the Gallery of DeCSS Descramblers, a collection of dozens of different descriptions for the DeCSS algorithm for unscrambling an encrypted DVD. The point of that page–and the point that Mr. Waxman is missing–is that all software, regardless of what language it’s written in, is simply a very precise description of a computational process.

Waxman tries very hard to obfuscate this point. For example:

JUSTICE SOUTER: So [your view is that] the component is the object code on the disk, not the disk itself?

MR. WAXMAN: That’s right.

JUSTICE SOUTER: All right. Then why doesn’t that get you right back to the point that Justice Breyer was making? You are saying, I think, in essence if you send a blueprint–this is like a blueprint. It tells, it tells a machine which may be in Europe how to put the object code on other disks or on hard drives. The machine in Europe is following instructions just the way an artisan would follow a blueprint. What is the difference?

MR. WAXMAN: Here’s the difference. And it’s nicely embodied in Microsoft’s reply’s use, repeated use of the word “antecedent.” A blueprint or a design is a precursor to the actual device. It is the instructions about how to make something. It’s not the thing itself. And here what we have is the object code that is the precise commands that, unlike design information, interact continuously with the hard drive and with the processor in order to make physical changes on an ongoing basis.

But this is nonsense. A CPU “continuously interacts” with a software program in precisely the same way that an architect “continuously interacts” with a blueprint while he’s supervising the building of a house. He’ll walk over to the blueprint, read a small portion of it, walk back to the construction crew, give the crew some instructions, and then walk back to the blueprint to read the next section. In precisely the same way, the CPU will fetch a segment of code from memory, execute it, write the instructions out to a different segment of memory, and repeat the process. The CPU operates a lot faster and goes through a lot more steps, but that’s a difference of degree, not one of kind. The software is still fundamentally a series of steps that the CPU reads and executes in sequence, just as a blueprint is a series of components that an architect reads and assembles in sequence.

All the Justices asking questions seemed to understand this. Waxman went round and round on this point, and didn’t seem to persuade any of them. So I’ll be shocked if Microsoft doesn’t win the case. The real question, in my mind, is whether the Supreme Court grasps the broader implications of the line of reasoning they’re pursuing here. The Software Freedom Law Center and others have urged the Supreme Court to take the opportunity to strike down software patents in general on precisely the grounds hinted at by the discussion above: that computer programs are nothing more than descriptions of mathematical algorithms, which the courts have always held are not patentable.

There are some encouraging signs. During Microsoft and the government’s oral arguments, Justices Scalia, Breyer, and Stevens all asked questions about whether software inventions are patentable in the first place, despite the fact that this wasn’t a question formally before the court. Given that the Supreme Court hasn’t squarely addressed the question in 35 years, that they ruled against software patents the last time, and that they seem none too happy with the way the Federal Circuit is handling things, it’s not crazy to think they could take this opportunity to strike down, or at least narrow the scope of, software patents.

Comments on this entry are closed.

Previous post:

Next post: