In February 2013 the US Patent and Trademark Office is holding Software Partnership meetings; one in Silicon Valley on February 12th and one in New York City on February 27th, 2013. According to the Federal Register announcement, "The Software Partnership will be an opportunity to bring stakeholders together through a series of roundtable discussions to share ideas, feedback, experiences, and insights on software-related patents."
Many of the patent attorney bloggers fear that the technology industry titans will turn the meeting into a patent-haters free for all. We fear that the technology titans who are always talking about the broken patent system will stay home and the only people who will show up will be patent attorneys and patent attorney bloggers just like the FTC/DOJ meeting on patent assertion entities. (Update — we were generally right.)
The meetings are being presented as roundtable events that will provide a forum for an informal and interactive discussion of topics related to patents that are particularly relevant to the software community. (Interactive? Let's hope that stakeholders aren't, well, holding any stakes.)
USPTO seeks to improve the quality of software related patents that use functional language seeking comments on, "How to improve the claim boundaries that define the scope of patent protection for claims that use functional language." The vertigo-inducing Federal Register announcement went further inviting attendees to make oral presentations on the advantages and disadvantages of applicants employing the following practices when preparing patent applications as they relate to software claims.
- Expressly identifying clauses within particular claim limitations for which the inventor intends to invoke 35 U.S.C. 112(f) and pointing out where in the specification corresponding structures, materials, or acts are disclosed that are linked to the identified 35 U.S.C. 112(f) claim limitations; and
- Using textual and graphical notation systems known in the art to disclose algorithms in support of computer-implemented claim limitations such as C-like pseudo-code or XML-like schemas for textual notation and Unified Modeling Language (UML) for graphical notations.
Ok, so the first one is generally linking the claims to the spec so that you can't have a claim for a a method to buy stuff over the internet without having language in the description that explains exactly what the invention does. Legalese aside, this seems to be a way to rein in the patent language stylists who have very large vocabularies and know all the overly broad words in the English language, or make up new ones when needed, to make the boundaries on what exactly the invention IS fuzzy. The tighter mapping, which seems to have disappeared for under a cloud of patent argot in software patents and its cousin, the business method patent, might help both the examiners and the rest of us trying to figure out what inventions ARE.
But Wait — This Might Work!!
The use of "textual and graphic notation systems" to disclose computer implemented claim limitations.
Before you click off to read something less mind numbing, consider the following. USPTO is going to try to manage the growth of software patents and the patent generating digital invention shops who patent ideas and not things simply by making the patent applications for these inventions much harder or, in some cases, absolutely impossible to file.It will also make it easier for patent examiners to compare it to prior art code narrowing the scope of the new invention.
First, what is a textual and graphical notation system? One ordinarily skilled in the art will know, but for everyone else a quick tutorial. According to the good folks at Wikipedia,
C-like pseudo code is generally an informal high-level description of the operating principle of a computer program or other algorithm. It uses the structural conventions of a programming language, but is intended for human reading rather than machine reading. Pseudocode typically omits details that are not essential for human understanding of the algorithm, such as variable declarations, system-specific code and some subroutines. The programming language is augmented with natural language description details, where convenient, or with compact mathematical notation. The purpose of using pseudocode is that it is easier for people to understand than conventional programming language code, and that it is an efficient and environment-independent description of the key principles of an algorithm. It is commonly used ... in planning of computer program development, for sketching out the structure of the program before the actual coding takes place.Usually pseudo-code acts as the glue between the business people who are defining requirements and the programmers who need to understand all the rules and processes before turning the requirements into software magic. (If you would like to see some samples, just search for pseudo-code in your favorite search engine.)
XML and Unified Modeling Languages are more high level versions of the same. Tags and text. Human readable representations of the processes. If USPTO adopts this type of annotation requirement to tie the content of the claims to the functional language in the specification, the inventor would need to write out in pseudo computer lingo or XML or UML exactly what the invention is doing, what the inventor is claiming. If you are a serious developer of digital business methods or digital software inventions, you do this anyway as you seek to reduce the invention to practice and to work through all of the permutations of how the invention would work in the real digital world. Real software needs to be built just like any other invention.
This raises some very interesting possibilities for improving the quality of software patents. Here are a few.
The Return of the Trade Secret Regime
Serious players are unlikely to not want to "teach" the honorable competition exactly how they programmed your giant automated package sorting-bar code reading extravaganza that lets you unload a lot of planes, sort all the packages using cool lasers and 3D barcodes, and then get all the packages back on the right plane or truck or bicycle to get them to the customer by the next day invention. Same with enhancements to the single action ordering system invention. So back to trade secrets and copyright protection we go. A lot of companies with significant software inventions didn't want to apply for patents but felt compelled to go down that path because their competition was. Reverting to a trade secret approach protects their proprietary methods just like in the good old days.
A trade secret approach to proprietary software inventions has the added benefit of making it much harder for the guys in China and elsewhere to steal innovations and market share. No more reading patent applications to figure out what is the next big thing. We expect that it is likely that there will be pushback from folks who will want to prevent publication of the pseudocode/XML/UML prior to granting the patent in light of how easy it would be to let someone clone the invention while the patent was being prosecuted. The other challenge will be how long it takes for the Patent Modeling Language Standards Coalition working group meetings to agree on a standard for including pseudocode in a patent application. Hopefully it will happen before the future standard is overtaken by… technology.) But this is for the policy wonks to deal with.
The White Board Only Invention Factory Will Face New Economics
Organizations that sit around and invent things but don"t actually build them let alone commercialize them would have to get really deep into the weeds to build a compliant patent application, it will take more people more time, and more money. It would also make getting software patents something not for the faint hearted. The added requirement for using notation to document processes is not something you do over the weekend. Requiring pseudocode to document the best mode of the invention would narrow white board inventions and help clarify the fuzzy and overly broad contents in a lot of software patents.
Invention vs. Vocabulary
Requiring a code-based roadmap between the claim and the spec so that you can determine what is really going on will, in and of itself, limit the scope of the software patent. There will be less left to future reinterpretation.
Consider the world of in-situ advertising (aka product placement advertising) in things like video games. While it may not totally eliminate writing stuff like this, it might help:
A method for providing intelligent advertisement placement in a motion picture, comprising: retrieving personalized data associated with a viewer; comparing the personalized data with a plurality of attributes, each attribute associated with an advertisement image, to determine an attribute that is most consistent with the personalized data; retrieving an advertisement image associated with the attribute that is most consistent with the personalized data; and imposing the retrieved advertisement image on a sequence of image frames of a motion picture.
Followed by some general, broad, fuzzy lingo in the spec like,
In the multi-media object management system, the production of the Master Program that is used to create the Multi-Media Program typically results in the presence of a plurality of Objects within the Master Program. The multi-media object management system defines a plurality of Multi-Media Object Locations within the Master Program as components of the Multi-Media Program and creates Object Management Data that is used to control the population of these spatial and temporal Multi-Media Object Locations with Objects. These Multi-Media Object Locations can receive animation, audio, moving Objects, stationary Objects, and any other dynamic data. The Multi-Media Object Locations are an integral part of the Multi-Media Program, and their content can be manipulated by referencing a specified Multi-Media Object Location and populating that specified Multi-Media Object Location with a predetermined rendition from the Objects stored in the database. Thus, the image of a beverage can in a Multi-Media Program is populated by any of a number of specific brands of beverages by importing a predetermined representation of the desired brand of beverage into the pre-defined Multi-Media Object Location that is an integral part of the Multi-Media Program. The multi-media object management system enables dynamic product placement in the delivery of a program to a recipient.
The inventor or team of inventors would need to explain how the multi-media objects are organized in the database, what the Master Program is and what it actually does, how the program determines which object to pull and under what circumstances, how the digital gizmo moves around the network before the soda ad hits your video game. The inventor would need to write a lot of complex pseudocode or use modeling language to explain how this invention works and what it does, a lot of if/thens will be required. It will take a lot of time, and a lot of really thinking through how these inventions will operate in the real world.
More Likely to Be Economically Important Inventions
This patent notation approach would make it more likely that an inventor willing to go through making this kind of disclosure has something novel and is more likely to commercialize a product or at least be moving in that direction. Independent inventors and start-ups might benefit by being able to show potential investors or customers how their product will actually work even if the notation requirement is burdensome. (Patent applications for small organizations are burdensome anyway.) It would make it harder for the white board patent shops that get a patent and wait for someone else to commercialize the "idea" and stop by for a visit to collect their royalties. It has the potential to streamline licensing discussions between operating companies and patent assertion entities by making it easier to have discussion on exactly how (if) a patented invention is being infringed.
The Programmer and Simultaneous Translator Careers
Now in addition to the gaggle of patent attorneys, claim constructors, drawing drafters, proof readers, and patent prosecution paperwork and fee coordinators, inventors wanting software patents would need to hire a programmer and simultaneous translator type who can both speak patent (generally the patent attorney variety rather than the more generic, "the patent system is broken" variety) and coding — pseudo-C, XML, or UML for the explaining the underlying invention. In theory, these folks should already be at hand, if you are trying to patent a software invention you should have software people. Finding third party talented enough (and patient enough) to do this ought to be interesting considering the sentiment of many software professionals who generally hate patents.
The Running Away With The Circus Prevention Plan
As if patent examiners don't have enough to do, they now will need to read lots and lots of code and fit that into the time allocated to each patent application for examination. (We assume that if you are examining software patents you should know how to read code.) But it's unclear how this new requirement will operate in the real world. Will this reduce pendency? Will the examiners have less but better quality applications to plow through? Code reading can be boring and dull especially if the code is not well done, not unlike the first round of claims sometimes. In light of that, USPTO might need to make sure that none of the teleworking or in-house examiners have access to internet sites or publications seeking people who want to run away with the circus. A day of code reading might make hanging with the elephants and professional clowns a more compelling and fun career option.
This Just Might Work.
USPTO has put forward a very interesting proposition — challenging and complex to implement but interesting none the less. If USPTO can avoid the Software Partnership meeting becoming a free for all for the patent hating crowd and if the serious patent people looking to rein in ridiculously broad software and business methods patents can stay focused on the implementation details of making such requirements a reality, this might just move the patent system to improving the quality of software implemented inventions.