Open up the patent granting process

Problem

Software patents are hard to understand. Really hard, because patent lawyers can get away with writing them in extremely vague and broad language. This means that innovators are left without clear guidance on what patents they might be infringing. It also allows trolls to exploit the vague and confusing patent language to extort higher licensing fees than they would otherwise be entitled.

Solution

Patent applicants should be required to provide an example of running software code for each claim in the patent and tell the Patent Office which claims are covered by which lines of that code. Think, for example, of early Patent Office practice requiring the submission of a “model” of the working invention to the Patent Office.

Joe Kowalski
United States
Posted Jun 19, 2012 6:49 pm
  • Software developer / engineer
  • Internet user
I would add to this that the demonstration program be should definitive in terms of setting the boundaries of the scope of the patent. Too often the patent claims are written in the vaguest, broadest language possible so as to maximize potential infringement and prevent work-arounds. If the demo program outlined the definitive scope of the patent, then the incentive to write vague overbroad patents goes away.
up
502 thumbs up.
Terry Ackey
United States
Posted Jun 20, 2012 6:40 pm
  • Software developer / engineer
Providing examples of code has nothing to do with the readability of a patent. What computer language will be used for that code example? C++? FORTRAN? If a programmer only knows Javascript, how does a code example in assembly language provide any guidance over an English description?
up
588 thumbs up.
Harry Hawk
Commodore USA
Lodi
NJ
United States
Posted Jun 20, 2012 2:02 pm
  • Academic
  • Internet user
  • Victim of patent troll
I want to address differences in computer platforms and why something would or would not be Obvious or non obvious. There should be a rule in software patent law that doesn't allow a patent to be valid just because the type of computer system or network, etc. is different. I will explain why below.

(The requirement of non-obviousness essentially means that the invention must not be an obvious variation or combination of subject matter previously known. http://www.dougweller.com/novelty.html)

Some technical jargon I may or may not have correct... my lay understanding is roughly that any Turing Machine/Von Neumann machine can emulate any other. My point, which might not be clear is that any computer can emulate any other.

Any computer can do something in software that any other computer could do -- THUS -- based on the issue of Novelty and Nonobviousness, if something has been done in prior art on one platform (in software) doing this on a different platform should be NON Novel and clearly Obvious.

Thus any platform specific software patents should be invalidated and there should be a review process for removing any existing patents which would violate this rule.

If a particular inventor feels this basic tenet of computer science doesn't apply to their "invention" and desires some form of redress a neutral 3 person expert panel would need to be certified as experts and brought into an appropriate hearing at the PTO to give testimony and to certify why a particular software patent is novel and Non-obvious.
up
540 thumbs up.
Mark Finch
Initiative Assets
Phoenix
AZ
United States
Posted Jun 19, 2012 6:04 pm
  • Software developer / engineer
  • Internet user
This is probably one of the most critical pieces of patent reform outside of abolishing software patents. Taking away patent trolls nearly zero cost game of claiming an invention without developing the invention would be a step closer to preventing the abuse the market currently has.

I propose that this be refined further that it doesn't prevent other implementations from being innovated. So if a patent is issued for "PRINT HELLO WORLD" it doesn't prevent someone from developing "WRITE HELLO WORLD". It is critical we give to software what hardware engineers have had for centuries a fair method of not infringing on a patent by developing a similar but different process.
up
519 thumbs up.
Harry Hawk
Commodore USA
Lodi
NJ
United States
Posted Jun 20, 2012 1:50 pm
  • Lawyer
  • Internet user
  • Victim of patent troll
The over all proposal by the EFF is excellent however it doesn't address one of the key points of failure for the PTO; that failure point is searches for Prior art. The PTO doesn't have right databases nor the proper training to find and spot prior art (according to many insiders).

Given the detailed level of domain expertise required to find and evaluate prior art, there needs to be crowd sourced review process. I am proposing a two level review which will accept comments from the general public as well as from member of a class of accredited peers.

My vision is: Tier 1 would be open to anyone but not binding on the PTO. Tier 2 members would accepted based on review of credentials (set by peer committee and PTO). Any prior art indicated by Tier 2 members as well as any Tier 1 art endorsed by a Tier 2 member would have to be addressed by the PTO before any valid patent is issued.
up
513 thumbs up.
Jorge Varas
RelProg
Derby
CT
United States
Posted Jun 21, 2012 6:25 am
  • Patent owner
  • Software developer / engineer
This should be made into a requirement in case of litigation. So the suing part needs to show proof that either has created such software, or own software that demonstrate the patent. And also so the defendant has an opportunity to show that the implementation is obvious, hence invalidating the patent.
up
506 thumbs up.
Glen Peterson
United States
Posted Jun 21, 2012 8:33 am
I can't imagine the virus/security nightmare of installing and running unknown software all day, every day, at the US patent office. Also running code is not always a great example of the patentable thing. In most cases, you'd need an analysis of the code to make running it meaningful. What programming language should be used? What platform should it run on? Would you vote for this if it meant that all patents had to be submitted to run on Microsoft Windows 7 and written in Visual Basic? I would not. Apple would be unable to patent certain aspects of their OS. You cannot use closures in VB, nor can you demonstrate data hiding well in Clojure. What about a software invention that takes advantage of unique hardware? Any choice of platform or language would be too limiting for someone.
up
467 thumbs up.
Gavin Roberts
Titusville
FL
United States
Posted Jul 25, 2012 5:28 pm
I keep coming back to thought that an idea, by itself, cannot be patented, only a particular implementation can be. This is an essential factor, in my mind, when considering the idea of code examples for each claimed patentable feature. As an example, consider that I might get an idea for a new serial communication based interface that takes advantage of encrypted communications to make it impossible or orders of magnitude more difficult to intercept the data being transferred to or from such a device. In order for me to be able to receive a patent for the driver of such a system, I should be required to present an example of such an implementation that adequately describes the process of communication between the device connected thusly and the host device, giving as granular a view as necessary to differentiate this implementation from another. This example might necessarily include psuedo-code that details the process of encrypting and then decrypting the device communications. This would allow for cases in which hardware encryption (or even multi-factor encryption) is used and the patent on the one implementation would not impair the ability to further innovate a new implementation.

This approach ignores the simple fact that patents are not the right vehicle to protect an implementation, however. We don't want web sites being patented, for instance. They neither represent a unique implementation of a technology nor do they describe a novel use of web standards and technology typically. That is what copyright(s) are for.
up
436 thumbs up.
Martin Garthwaite
personal
Seattle
WA
United States
Posted Feb 4, 2013 8:24 am
  • Lawyer
When submitting code, one alternative is to submit compiled object code which is executed by a reference hardware/OS combination. The reference hardware/OS can be provided by open source communities and by private OS builders (Microsoft, Apple, Blackberry). The reference hardware/OS would have an emulator which would have to be maintained over time, so that people could go to the USPTO and run applications on the emulators. Hardware/OS providers have an incentive to maintain these reference environments, because doing so would attract developers to the platform and because it would greatly reduce troll activity. Source code could also be provided, but in an encrypted form, for use during (rare) litigation. The "reference" environments would have to include "dummy" client/server units with which the software interacts (most software patents involve multiple third party components), but these can be built showing test interactions and don't have to be a real client/server. Failure to maintain a software application so that it can be run (failing to maintain a "reference" build) would invalidate a patent. A patent could be granted immediately for "everything new and non-obvious" in the submitted software. The initial submission would be relatively inexpensive and wouldn't require a patent attorney. However, enforcement of the patent would require defining what was "new and non-obvious," which is when money would have to be paid to lawyers/experts (same as happens in patent litigation now).
up
435 thumbs up.
Alex Burr
Canbridge
United Kingdom
Posted Jul 1, 2012 7:24 am
  • Software developer / engineer
  • Internet user
I agree that software patents are usually vague. I'm not convinced that giving examples solves the problem (although it might help a bit).


There are two problems which giving an example does not solve:
First, what we need to be precise is the *boundary* of the claim, as noted by other commenters. An example is merely some point within the boundary.

Second, we need to efficiently locate patents which we are in danger of infringing. This is the 'Notice function' of property, which in "Patent Failure" Bessen and Maurer correctly state is failing in the case of patents. As noted by Lee and Mulligan in "Scaling the Patent system", software patents are not indexable in the same way that you can index chemicals by their chemical formula. In fact, indexing software is impossible in the general case (if you could do it, you could also solve the halting problem!).

I have been thinking about a system along the following lines:

Imagine that at a given point in time, the patent database included not just the individual patents, but a '20 questions' style index, whereby any patent could be located. Crucially, no patent could be enforced against anything outside the 'bucket' in which it is indexed. (A patent could be indexed in more than one bucket, but only by paying the fee for each.) This would have two effects: first, it would be a lot easier to find patents you are in danger of infringing. Second, the boundaries between buckets would be defined much more precisely than those of an individual patent. Why? When drafting a patent, the incentives are to make it as vague as possible. But in the case of the buckets, the incentive is more like drawing a boundary line in real property: because the line affects those on both sides, one's loss is the others gain, so each pushes to make sure his own property is clearly demarcated.

Such an index would have to be rebalanced every so often, like a binary tree. So patent owners would need to monitor where their patent had been moved to. Ironically, patent lawyers may actually like that - it would involve them in more work.
up
435 thumbs up.

Pages

Dan Carr
United States
Posted Jan 27, 2015 3:01 pm
only as plan b - software should not be patentable.
up
207 thumbs up.
Martin Garthwaite
personal
Seattle
WA
United States
Posted Feb 4, 2013 8:24 am
  • Lawyer
When submitting code, one alternative is to submit compiled object code which is executed by a reference hardware/OS combination. The reference hardware/OS can be provided by open source communities and by private OS builders (Microsoft, Apple, Blackberry). The reference hardware/OS would have an emulator which would have to be maintained over time, so that people could go to the USPTO and run applications on the emulators. Hardware/OS providers have an incentive to maintain these reference environments, because doing so would attract developers to the platform and because it would greatly reduce troll activity. Source code could also be provided, but in an encrypted form, for use during (rare) litigation. The "reference" environments would have to include "dummy" client/server units with which the software interacts (most software patents involve multiple third party components), but these can be built showing test interactions and don't have to be a real client/server. Failure to maintain a software application so that it can be run (failing to maintain a "reference" build) would invalidate a patent. A patent could be granted immediately for "everything new and non-obvious" in the submitted software. The initial submission would be relatively inexpensive and wouldn't require a patent attorney. However, enforcement of the patent would require defining what was "new and non-obvious," which is when money would have to be paid to lawyers/experts (same as happens in patent litigation now).
up
435 thumbs up.
Mark Lemley
Stanford Law School
Stanford
CA
United States
Posted Sep 20, 2012 4:59 pm
  • Lawyer
  • Academic
  • Internet user
The problem is not simply that too many patents don't involve running code, but that even the ones that do are not limited to the actual solution the patentee came up with. The patent claims are written in broad functional language, so that the patentee owns ANY solution to the problem, not just the one they provided. There is a simple legal fix to this: require software patent claims to be limited to the actual solution disclosed or its equivalent. My paper "Software Patents and the Return of Functional Claiming" discusses the problem and how to solve it. http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2117302
up
429 thumbs up.
Mike Boucher
Dakota Legal Software, Inc.
Lafayette
CO
United States
Posted Sep 5, 2012 12:27 pm
  • Patent owner
  • Software developer / engineer
  • Internet user
The proposal states that "applicants should be required to provide an example of running software code for each claim in the patent." I'd be happier if the proposal used the language of patent law rather than the colloquial phrasing that it uses because then I would feel more confident that the proposer actually knows what he is proposing and why it is wrong.

One of the requirements of getting a patent is that the patent must be enabled. There are two ways to enable a patent, those being actual enablement and constructive enablement. A patent is actually enabled by a working invention. A patent is constructively enabled by a description of how to practice the invention, but lacks a working invention.

A blueprint is a constructively enabled house. It describes how to build a house, but usually does not actually come with a house. A house is an actually enabled house. If you were to purchase one of those, the blueprint would generally be cheaper than the actual house, but that is not to say that architects cannot be paid for creating blueprints at all.

In terms of patent law, the proposal here is to disallow constructive enablement of patents, but only for software. Ask two questions. First, what purpose is served by constructive enablement, both generally for patent law as a whole and for software specifically? Understand what you're throwing out before you throw it out. Second, what is special about constructive enablement as applied specifically to software? Understand whether it makes more sense to figure out how to fix constructive enablement system-wide rather than just applying a (probably ill-considered) ban on constructive enablement for exactly one specific type of invention.
up
426 thumbs up.
Renee Jones
Lockheed Martin (opinions are my own)
Glendale
AZ
United States
Posted Aug 23, 2012 10:46 am
  • Software developer / engineer
  • Internet user
I saw some people concerned about what language would be used for the examples. This does not matter and should not be an issue. It is not an issue when academic papers are submitted. When I was in school, it was assumed that any graduate student in computer science could program in any language chosen by the professor with a week or two of introduction. Experts in the field should have no problem whether the examples are in fortran, java, assembly language, lisp or even prolog. It simply does not matter to a true expert.

Secondly, I would like to insist that any code samples used in a patent application should, by law, be placed in the public domain with respect to copyright. If we decide to grant software patents, and if a company wants a patent on their software, then they should have to give up any and all copyrights regarding the software that implements the patent. Once the patent expires, the code and the patent should be fair game for anyone to use.
up
432 thumbs up.
Gavin Roberts
Titusville
FL
United States
Posted Jul 25, 2012 5:28 pm
I keep coming back to thought that an idea, by itself, cannot be patented, only a particular implementation can be. This is an essential factor, in my mind, when considering the idea of code examples for each claimed patentable feature. As an example, consider that I might get an idea for a new serial communication based interface that takes advantage of encrypted communications to make it impossible or orders of magnitude more difficult to intercept the data being transferred to or from such a device. In order for me to be able to receive a patent for the driver of such a system, I should be required to present an example of such an implementation that adequately describes the process of communication between the device connected thusly and the host device, giving as granular a view as necessary to differentiate this implementation from another. This example might necessarily include psuedo-code that details the process of encrypting and then decrypting the device communications. This would allow for cases in which hardware encryption (or even multi-factor encryption) is used and the patent on the one implementation would not impair the ability to further innovate a new implementation.

This approach ignores the simple fact that patents are not the right vehicle to protect an implementation, however. We don't want web sites being patented, for instance. They neither represent a unique implementation of a technology nor do they describe a novel use of web standards and technology typically. That is what copyright(s) are for.
up
436 thumbs up.
Jeff H
United States
Posted Jul 2, 2012 12:37 pm
  • Patent owner
  • Software developer / engineer
  • Internet user
Software is not patentable - only a process or algorithm. The writers of this petition need to be clear on this point, otherwise no legal counsel or member of the legislature will listen to the valid points.
up
434 thumbs up.
Keith Laws
United Kingdom
Posted Jul 1, 2012 1:52 pm
  • Internet user
Patents are meant to be for solutions to problems, not about the problem itself. Allowing you to patent the problem without showing how you solve it is insane! Of course the application should be accompanied by running code.
up
433 thumbs up.
Alex Burr
Canbridge
United Kingdom
Posted Jul 1, 2012 7:24 am
  • Software developer / engineer
  • Internet user
I agree that software patents are usually vague. I'm not convinced that giving examples solves the problem (although it might help a bit).


There are two problems which giving an example does not solve:
First, what we need to be precise is the *boundary* of the claim, as noted by other commenters. An example is merely some point within the boundary.

Second, we need to efficiently locate patents which we are in danger of infringing. This is the 'Notice function' of property, which in "Patent Failure" Bessen and Maurer correctly state is failing in the case of patents. As noted by Lee and Mulligan in "Scaling the Patent system", software patents are not indexable in the same way that you can index chemicals by their chemical formula. In fact, indexing software is impossible in the general case (if you could do it, you could also solve the halting problem!).

I have been thinking about a system along the following lines:

Imagine that at a given point in time, the patent database included not just the individual patents, but a '20 questions' style index, whereby any patent could be located. Crucially, no patent could be enforced against anything outside the 'bucket' in which it is indexed. (A patent could be indexed in more than one bucket, but only by paying the fee for each.) This would have two effects: first, it would be a lot easier to find patents you are in danger of infringing. Second, the boundaries between buckets would be defined much more precisely than those of an individual patent. Why? When drafting a patent, the incentives are to make it as vague as possible. But in the case of the buckets, the incentive is more like drawing a boundary line in real property: because the line affects those on both sides, one's loss is the others gain, so each pushes to make sure his own property is clearly demarcated.

Such an index would have to be rebalanced every so often, like a binary tree. So patent owners would need to monitor where their patent had been moved to. Ironically, patent lawyers may actually like that - it would involve them in more work.
up
435 thumbs up.
Gunnar Wolf
Universidad Nacional Autónima de México
Mexico
Mexico
Posted Jun 21, 2012 9:34 am
  • Academic
  • Software developer / engineer
I understand the point this campaign seeks is to reduce the harms software patents currently create. However, we must keep the focus on the abolition of software patents — A majority of countries in the world still don't recognize them as valid, fortunately. The USA has long been pushing for their inclusion in their different national laws, but (fortunately) it's not been a easy thing to do.
Still, an organization with such a prestige as the EFF should *clearly* state that anything in this list of priorities, while important to fix the status quo, is still not enough: The only sane way out is to keep patents limited to industrial processes, as they were originally conceived, and leave nontangible inventions outside of their umbrella.
up
430 thumbs up.

Pages

First
Last
JavaScript license information