Timothy B. Lee — Writer with Ars Technica and the Cato Institute
A major reason for the recent explosion of patent litigation is that it’s hard for software firms to figure out which patents they’re in danger of infringing. There are hundreds of thousands of software patents in existence, with more than 40,000 new ones issued each year. Indeed, in a recent paper, Christina Mulligan and I estimated that it’s effectively impossible for all software-producing firms to do the legal research, known as a “freedom-to-operate” (FTO) search, required to avoid infringing software patents—there simply aren’t enough patent attorneys to do the work. That’s a major reason why most software firms simply ignore the patent system.
One of the striking things about the patent debate is vast gulf between the views of computer programmers on the one hand and patent attorneys on the other. Steve Lundberg is a patent attorney and blogger who mentioned our paper in a blog post exploring the challenges of performing FTO searches in the software industry. I don’t want to pick on Lundberg, because I think you’d get similar arguments from many patent lawyers. But his post shows a fundamental lack of understanding of how the software industry works. For example:
Due to the nature of patenting, the vast majority of patents are narrow in scope. This is due to the novelty and obviousness requirements, and due to the fact that there is, after all, tons of prior art, much of which is freely available to find on the Internet. This means that, both in theory and in practice, it is improbable that any software developer will accidentally infringe a patent, unless that patent is one of very few that are truly broad in scope. If software patents were a minefield for developers, the mines would generally be at least 5 miles apart, making accidentally stepping on one a very low probability occurrence.
As a matter of patent theory, Lundberg is absolutely correct. Patent law’s novelty and obviousness requirements are supposed to narrow the scope of patent protection. But in practice he’s dead wrong. The patent office issues a seemingly endless stream of patents on broad, obvious concepts like emoticon menus, one-click shopping, and wireless email.
And the existence of these broad, obvious patents means that software companies are constantly infringing each other’s patents by accident. The companies with the largest patent portfolios, such as Microsoft and IBM, have tens of thousands of patents, allowing them to credibly threaten almost anyone in the software industry. Even Yahoo, with its relatively modest cache of 1000 patents, was able to find ten patents to assert against Facebook.
Now, Lundberg might be technically right that this type of broad, obvious patent is a minority of those issued by the patent office. But he fails to grasp the issue of scale here. Even if the risk of stepping on any particular mine is small, there are now so many mines in the field that it’s essentially impossible to walk across it without stepping on a few of them.
For any given software product, the developing entity is only adding value/innovation at a particular layer/customization of the software product they are implementing. The developing entity need only focus on the software patents applicable to that layer, not to all the sub-components they purchase from other parties, such as database software or web servers or programming languages and libraries, etc. Each player in the software ecosystem is, generally speaking, responsible for their own part of the overall software “stack.”
Once again, this is a plausible theory but has no bearing on how the actual software industry works. For example, Lundberg seems oblivious to the existence of open source software, which these days is used by everyone from Google and Apple to tiny startups. Microsoft’s lawsuit against GPS maker TomTom is a good example of the problem. TomTom built its GPS product on top of the open source Linux operating system, and Microsoft sued because the Linux file system allegedly infringes one of Microsoft’s patents. A patent search that focused only on the specific software TomTom wrote, as opposed the much larger body of Linux code, would never have found the patent at issue in Microsoft’s lawsuit.
For most software start-ups, where the ability to fund FTO is most strained, the core innovative concepts of the proposed software design can be thoroughly researched for under $25,000.00, and the results of that FTO study can be used both to design around, most often, most of the pertinent patents, and also ascertain whether the proposed design will be eligible for its own patent protection. Given that it typically takes many millions of dollars for a software product to make it to market, this is a small expense.
For reasons we explain in our paper, I doubt Lundberg is correct that a thorough patent search can be done for less than $25,000. But even if he’s right, this is hardly a “small expense” for a typical software-producing firm. For example, one popular Silicon Valley startup funding organization, Y Combinator invests around $20,000 and expects that to be enough money for a new firm (typically two or three 20-somethings) to produce a working prototype over the course of a summer. Expecting such a firm to blow $25,000 on patent research before they begin implementing their idea is hardly reasonable.
Lundberg’s argument becomes even less plausible when we remember that hundreds of thousands of firms outside the traditional software industry produce custom software for their own use. For example, the Atlantic, like many other online publications, uses a lightly modified version of an open-source software package called Moveable Type to manage its website. Did the Atlantic hire a patent lawyer to inspect its Moveable Type installation and license any relevant patents? I’m sure they didn’t, but in principle they’re just as vulnerable to patent lawsuits as a traditional software company would be. For example, the Green Bay Packers, Caterpillar, Peapod, OfficeMax, and Kraft Foods were all hit with a patent infringement lawsuit for having JPEG images on their websites.
So why is Lundberg so oblivious to the realities of the software industry? Julian wrote on Wednesday about peoples’ tendency to extrapolate from their own experiences. Lundberg’s post is not an accurate description of the software industry as a whole, but it probably is an accurate description of the parts of the software industry he sees on a regular basis. By definition, Lundberg’s clients are drawn disproportionately from the minority of software firms with the resources and infrastructure to effectively navigate the patent system. This means he rarely interacts with the vast majority of software-producing firms who only deal with the patent system when they are forced to do so by an unexpected cease-and-desist letter.
Consider, for example, the patent troll Lodsys, which began extorting money from small app developers
last year. For the small firms targeted by Lodsys, the rational thing to do is to pay the money Lodsys demands whether or not the target believes he’s actually guilty. That’s because the legal costs of defending against a patent lawsuit is likely to vastly exceed the amount of money Lodsys is demanding. But because many targets of frivolous patent threats settle their cases quickly, guys like Lundberg rarely interact with them. In other words, Lundberg works with the patent system’s winners on a daily basis, but he rarely interacts with the system’s losers, even though there are many more of them.
As a result, there’s a deep and persistent rift between the community of computer programmers, who are overwhelmingly hostile to software patents, and patent lawyers who seem mystified by all the outrage. The job of a patent lawyer gives him a systematically skewed understanding of how the patent system affects the software industry.