What are you using to extract the intention from unstructured language? In my current project at work I have implemented coarse geocoding (finding places in raw text) using the Stanford NLP model as well as Open NLP. Are you using a similar approach?
Not at all. Our approach is based on simple "recognition" and "matching" rather than detailed grammatical and semantic analysis. At the risk of sounding facetious, it is an extension of some real-world research performed and documented by Gary Larson:
To be more specific. When we say to a dog, "Want to play fetch with the ball?", we believe the dog responds appropriately, not because he grammatically analyzes the whole sentence and derives its semantic intent from that analysis, but simply because he
recognizes a couple of the words and is able to
match them with things already in his head. So he hears, "blah blah blah FETCH blah blah BALL" and matches the two words he recognizes with his mental image of a generic ball (similar to a "type definition" in a program), and perhaps his mental image of a particular ball (similar to a program "variable"), and his method for fetching ball-like things (similar to a "routine" in a program). In Plain English:
A ball is a thing with... [this defines "ball" as a type]
The red ball is a ball. [this defines "red ball" as a variable of type "ball"]
To fetch a ball: [this is a routine header with an unclassified word ("fetch") and a type ("ball")]
And that's the stuff in the "compiler's head" after its done "learning" about the programmer's world.
Now consider what happens when the compiler comes across an imperative sentence like this in the body of a routine:
Fetch the red ball.
Parsing from left to right, the compiler collects everything up to the article ("the") and, since what it has found is not a variable, assumes that is just part of a routine name (we call it a "monikette" -- part of a routine's "moniker" or "name"). Then it throws away the article and sucks up the rest of the sentence, which turns out to be a variable of type "ball". Then it concatenates the monikette with the type name and goes looking through the headers compiled earlier for an appropriate routine to call. When it finds one, as in this case, it generates the code to make the call; if it doesn't find a match, it says something like, "I don't know how to 'fetch a ball' " and the programmer then makes the necessary corrections and/or additions to his code.
The beauty of this approach is that the vocabulary of a program, and indeed, much of the grammar, is defined, not by the compiler, but by the programmer himself as he develops his system. The compiler is only interested in a handful of English "separator words" -- articles, prepositions, conjunctions, and various forms of the verb "be".
Now I realize this approach sounds both simplistic and sloppy; but the fact is, it works. And not just for dogs and small children. Using little more than what I've just described, we were able to write an entire development system (with a unique interface, a simplified file manager, an elegant text editor, a hexadecimal dumper, a native-code-generating compiler/linker, and a wysiwyg page-layout facility for documentation), in Plain English, both conveniently and efficiently.
So three cheers for Gary Larson! We wouldn't be where we are today without him.