Take the 2-minute tour ×
Ask Patents is a question and answer site for people interested in improving and participating in the patent system. It's 100% free, no registration required.

To be fair, I think this is a ridiculously better software patent than any of the other ones I've seen, but I bet there is prior art for it.

The first claim:

1. A method for correcting semantic errors in code in an integrated development environment, said method comprising the steps of:

  • inputting, using a code editor, code being developed in an integrated development environment;
  • identifying, in a syntax tree constructed for said code inputted, one or more nodes containing semantic errors pertaining to use of a third-party library;
  • displaying one or more suggestions for correcting said semantic errors identified for a node in said syntax tree containing said semantic errors, wherein said one or more suggestions include one or more executable code snippets associated with one or more collaboration records located for a chosen node from the syntax tree;
  • selecting at least one executable code snippet from said one or more executable code snippets displayed for correcting said semantic errors identified for said chosen node, wherein said at least one executable code snippet comprises a primary executable code snippet and a secondary executable code snippet;
  • executing, by a computer, the primary executable code snippet;
  • and in response to the primary executable code snippet failing to correct said semantic errors identified for said node chosen, automatically executing the secondary executable code snippet.

My non-legalese summary:

Finding semantic code errors in a syntax tree, picking up two likely corrections based on a body of previous code, and compiling and executing the snippets to see if they correct the semantic error.

share|improve this question
Is there a patent (application) number associated with this? –  Elijah Lynn Oct 4 '12 at 15:02
Lol, this patent would be unusable in a real world situation. Not all errors produce an error, not all errors are traceable to a specific line of code. If anyone actually tried to use this, they would actually totally screw up the debugging procedure instead of simplifying it... You would need a neural net with human visual analytical procedures to be actually able to use this... Just my two cents, but I like the way it's described, unreadable but with a lot of self added comma's a little bit understandable. –  Michael Dibbets Sep 13 '13 at 14:26

6 Answers 6

I've looked through the full application, and it clearly was written to be completely unintelligible, which is not what patents are supposed to be for. As a practitioner skilled in the art, I still have no clue what they're getting at with the last three bullet points, or what properties something would need to constitute prior art. Here's a fairly typical sentence from the so called "summary":

In an embodiment, the identifying step further includes the step of providing a collaboration datastore for storing the one or more collaboration records containing respective invocations for identifying the one or more nodes containing the semantic errors, where a collaboration record includes one or more properties and where a respective invocation of the respective invocations includes a type of invocation and one or more parameters.

That clearly was written by someone trying to obscure, not someone trying to communicate. For that reason alone, this application should be rejected.

Doing a lot of reading between the lines, I think the original idea is supposed to be something like this: you have multiple developers working on the same code and submitting fixes to bugs. When two different developers submit fixes for the same bug, it automatically tries both of them (perhaps running a unit test?) and accepts whichever actually fixes it. But that's just a guess. The application certainly doesn't say anything like that. It also keeps jumping between two seemingly separate ideas and confusing them with each other: interaction with the user, and automated error correction. For example, the third bullet point in claim 1 speaks of "displaying one or more suggestions" to the user, indicating this is an interactive feature and the user will be selecting one of them. But the remaining bullet points somehow jump to an automated system where the computer selects among various alternatives in an automated way with no user interaction required. So which is it actually doing? That's impossible to determine from the claim as written.

share|improve this answer

This may not be a complete answer, but your summary:

Finding semantic code errors in a syntax tree, picking up two likely corrections based on a body of previous code, and compiling and executing the snippets to see if they correct the semantic error.

sounds exactly like the "auto correct" behavior that MS Word exhibits. For example, typing "teh quick brown fox" will result in an automatic change of "teh" into "the". An error was found in the current line, the most likely correction was selected based on regular language rules (code), and the word was replaced to correct the error. While this does not correct programming code, or test by executing corrections; it does the same process as described above within the scope of a text document.

share|improve this answer
The non-obvious part would be this section: "executing, by a computer, the primary executable code snippet; and in response to the primary executable code snippet failing to correct said semantic errors identified for said node chosen, automatically executing the secondary executable code snippet" That is what makes Word's spell check not prior art for this patent. –  Michael Pryor Sep 26 '12 at 17:45
That part is classic "exception handling", I have been doing it for years with ColdFusion (CFTRY/CFCATCH). I'll find the oldest online reference and post links and analysis a little later. –  Ron J. Sep 26 '12 at 17:55
Semantic errors not syntactic errors. Semantic errors are logic errors and cannot be detected by the method suggested here. –  Diego Escalera Sep 26 '12 at 19:44

I'm not clear on what the last three bullet points are getting at - it might be clearer if I read the whole patent. But the rest sounds very similar to the automatic error checking found in many IDEs (such as Intellij IDEA). In particular:

  • You enter code.
  • It parses your code and generates a syntax tree for it.
  • It identifies semantic errors related to third party libraries. In the case of IDEA, that largely means the standard Java class libraries. For example, it will detect if you call toUpperCase() on a String and forget to assign the result to something, or call read() on an InputStream and don't check the return value to see how much was actually read. It knows these are common mistakes.
  • It often will offer suggestions for how to fix the error.
share|improve this answer
That's part of the patent, but the entire patent describes that system PLUS the act of executing the code (i.e. not just looking up ) to see if it works, and then using that as the correct substitution. The execution is the key component. –  Michael Pryor Sep 27 '12 at 21:55

executing, by a computer, the primary executable code snippet; and in response to the primary executable code snippet failing to correct said semantic errors identified for said node chosen, automatically executing the secondary executable code snippet

This portion perfectly describes the ColdFusion error handling. ColdFusion is a web application server, that supports its own programming language CFML.

From the book Mastering ColdFusion 4 - Jun 1, 1999 (the oldest edition of documentation I could find online). Google: http://books.google.com/books?id=ItBQAAAAMAAJ Amazon: http://www.amazon.com/gp/search?index=books&linkCode=qs&keywords=0782124526

The book describes the error handling functionality of the tag CFCATCH. I will paraphrase here, relating prior art to the quoted segment above. Google in-book search for CFCATCH shows part of the content.

A block of programming code is encapsulated in a CFTRY tag set. Any errors that occur in the primary executable code within this segment is intercepted - thereby preventing a program crash. At the bottom of the CFTRY code block, the tag CFCATCH can be used in response to error conditions to catch programming errors. Secondary executable code is placed within the CFCATCH tag encapsulation. CFCATCH supports several parameters which allow you to use multiple iterations to catch different error conditions, with new code to be executed for each node that could have failed. Each CFCATCH block can execute alternate programming code in lieu of the original error causing code (node), thereby self correcting the behavior of the overall program.

Every high level programming language has this kind of exception handling, maybe worded differently but the concept is definitely prior art.

share|improve this answer
I think this isn't prior art either. The patent isn't for a classic case of error handling, it is for CORRECTING semantic errors by trying other little snippets, and executing them to see if the program compiles correctly and runs correctly. Its not related to CFTRY or CFCATCH blocks at all, but I very much appreciate the time you spent answering. –  Michael Pryor Sep 26 '12 at 20:28
But CFCATCH does allow alternate code to be executed instead of the original (error causing) code. Multiple CFCATCH blocks will in fact allow one to catch a "plurality" of error conditions, and replace the problem code with alternate code (in effect, trying alternate code till the error goes away). That is pretty much my reading of the translation you posted. –  Ron J. Sep 26 '12 at 20:55
The key here is that they are not executing the code under the circumstance when an error in the code happens. This is not a try/catch thing. They are, in an IDE, a development environment, trying to fix semantic errors in the way the user has typed code, by running alternate code fragments and seeing if they succeed. It's not related to what you are describing. –  Michael Pryor Sep 26 '12 at 21:30
Ah, the IDE, I assumed it was executing code, not just being entered. Point taken. –  Ron J. Sep 26 '12 at 21:36

I realise it might be veering slightly off topic (patent law), but having done a fair bit of programming (both in IDEs in high-level languages and in assembly-language) I question how beneficial the try-to-execute methodolgy can really be:

  • Almost any high-level-language code which parses and compiles is likely to be successfully executable (as long as the variables/pointers/functions it uses are valid at the time of execution). What kind of additional programming errors will this method actually detect?
  • What if the programmer hasn't yet written the surrounding code which defines the 'environment' of the code which is being entered/edited?
  • What if the code path is heavily depended on some 'live' data stream which is not available when the code is written/in the IDE? (I acknowledge that for reliability and security a program which takes input data really ought to be robust against any corrupt or malicious data)

Maybe it's my lack of imagination, but I'm struggling somewhat to visualise circumstances when this try-to-execute would be of great benefit.

Maybe I'm mistakenly interpreting the use-case as a check-as-you-type, when this was not implied?

And of course the danger of any kind of 'auto-correct' is that it silently 'corrects' things to something other than the author's intention!

share|improve this answer

Also sounds like what T9 Predictive Text is doing on old feature phones for text messages. I.e. based on the keys typed predicting the word which the user is trying to enter, and if multiple words matches allowing the user to select the word from a list which matches the intent.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.