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.