Over at his blog, Mitcho has some very sharp thoughts about localizing Ubiquity to verb-final languages such as Japanese.
I talked about similar localization issues several months ago, but Mitcho takes it further than I did. He says:
In a verb-final language, however, you enter the arguments first and then the verb, making this strategy of suggesting appropriate arguments impossible.
…
Instead of seeing this as a disadvantage, however, let’s see what verb-final order allows us to do.
That’s the spirit!
He goes on to talk about analyzing the arguments, which are entered first, and using them to suggest a verb. I think this is exactly the right idea.
I’ve just got one thing to add: Ubiquity already does some very rudimentary suggestion of verbs based on having the nouns first. This is how we handle the case where the user selects some text and then pops up the command line — we suggest verbs based on the noun types that produce a positive match to the selection. It’s very basic right now, and could be a lot better.
The good news is that we can take the algorithm that suggests verbs based on the selection, and apply it to Mitcho’s idea of suggestions in verb-final languages. Any improvements we make in one will be applicable to the other, and vice versa. Working on the noun-first suggestion algorithms helps everybody!
Not The User's Fault 
March 10, 2009 at 6:36 pm
[…] Verb-final languages: An advantage? by Jono […]
March 11, 2009 at 3:36 am
[…] Verb-final languages: An advantage? by Jono […]
July 13, 2009 at 3:45 pm
It looks pretty good so far, and I think that people will like it.
June 9, 2011 at 6:35 pm
In computer language syntax definition, I wonder why most object interfaces slavishly tie themselves to a strict ParentObject.ChildObject(s).MethodOrProperty to access things that are “part of” an object. (Define, for the moment, that any property assignment or call is effectively a verb, and the context defining objects are the subject and possibly the direct objects, while the arguments are, for the most part adverbial.)
The verb names are often linked tighter to the meaning than to the computer languages formal object type definitions. That’s because names for such things are generally derived from native language, irrespective of computer language. It’s valid information to use.
It bears noting, as well, that the programmer defining a specific program element knows what they mean a name is meant to convey. Some of this could be part of a program or or supplemental data fed to the system on a per-program basis to assist use/to give the linguistic intent of a command name.
A formalized approach to determining what context (parent/children object(s) in the former example) could allow an investigation into the patterns that could possibly fit. Just index both by verbs (and their required arguments. e.g. subjects/direct objects) and nouns (as subject or direct objects). Then check by command elements and see which possible interpretations fit.
You would need some way of defining sets of objects, at least. An efficient specification of grouping is a minimal requirement, as far as I can see. I think syntax clues as to which elements are subjective, objective, verbal, or adverbial would have to be uniquely devised per language, unless some universal target is defined. Common verbs (and exceptions could be weighted by the percentages of a group that do not fit the interpretation. If so, the exceptions should also be marked in the feedback in some way.) should be able to be accessed, even from disparate sources. (A text file sent to a window object and a printer with the command “Print” probably ought to print into the window and onto some real paper, though the objects involved are unrelated.)
The goals you mentioned in the linguistic UI were wise. Pretty much any language will have different ways of solving some of these issues, so I’m doubtful that a single answer will work for all languages, but the gist of what you’re seeking is a great idea.
I think two layers makes sense- one back-end with a strict syntax that clearly defines what each element means, preferably very efficiently; and a modular linguistic expert system to parse natural requests (or simply pieces thereof) into the other language. The option of allowing intermingling is interesting, but may be too cumbersome to parse meaningfully.
Any interesting progress?