🚀 go-pugleaf

Another way to look at the noun-verb order concerns the number of nouns which
are involved.  I think there are three cases which are:

1.  one verb and no nouns

2.  one verb and exactly 1 noun

3.  one verb and 0 or more nouns


The first one is the trivial case where the verb doesn't operate on any nouns.

The second case is one where a noun must be provided for the verb.  In this
case, both pieces of information are needed before any error checking is
done or any resources, e.g. locks, printers, are requested.  Since both
pieces are needed before any processing can continue, the order may not be
as important.  One consideration might be that if the verb is chosen first,
the interface could indicate appropriate noun choices, e.g. highlighting or
popping up menus or text fields.  Similarly, choosing the noun first could
allow the system to indicate appropriate verbs.

The third case is used to specify several nouns.  It is useful for specifying
a list of objects where the action is performed on each object, e.g.
printing a file.  For an expert user, it increases effificiency because
he/she specifies the verb only once instead of once for each noun.  A list of
nouns can alo be used to specify a relationship among the list of nouns or build
a noun aggregate, e.g. specifying a group of the objects.

Specifying a list of nouns can have one of the two following forms:

	<noun> <noun> ... <verb>

	<verb> <noun> <noun> ... <terminator>

In the first form, the verb has the dual purpose of specifying the action
and terminating the list of nouns.  In the other form, a terminator
is used to signal the end of the list of nouns.

The main advantage of the first form is that the user doesn't have to specify
a terminator.

The second form has several advantages.  One advantage to the second form
is that error and resource checking can be performed as each noun is
selected rather than after the entire list is specified.
Checking each noun as it is selected is much less frustrating
for the user since the user knows immediately that there is a problem
rather than at after specifying the entire list.  If the error or resource
checking occurs at the end of the list, the user will need to specify the
entire list again.  Also, if more than one noun has an error, pairing
errors and nouns after the list is specified can be confusing or
time consuming.


Another advantage to the second form is that more support can be provided to
the user when specifying complex syntax.  Complex syntax has the advantage of
improving user efficiency by increasing the brevity of commands.  In this
example:

     save noun-1 to noun-100 except noun-34

the "to" and "except" are nouns used to modify and shorten the command.
The syntax uses fewer nouns than:

     save noun-1 noun-2 ... noun-33 noun-35 ... noun-100

Complex syntax also increases the expressability of the interface.

In more complex syntax, the relations between the nouns and the order
of the nouns becomes much more significant.  The example could be written
as:

     noun-1 to noun-100 except noun-34 save

However, the interface cannot prompt as easily because it doesn't know the verb.
Since the interface cannot assist the user through the complex syntax,
the user will be forced to learn and remember the syntax.  This user
requirement will increase the amount of effort the user will need to exert
in order to take advantage of the complex syntax.  The result will be that
few users will take advantage of the complex syntax which will thwart
the purpose of the syntax.

If the verb is at the beginning of the noun list, the interface can assist
the user through complex syntax by prompting.


The second form is much more user-friendly and can provide
facilities which can significantly help expert users.


If the application is simple with no noun aggregates and need not worry
about expert users, the choice between noun-verb or verb-noun order
can be made on other criteria.  If the application is complicated or
will have expert users, the verb-noun order is probably preferred
because it can be expanded into supporting noun aggregates or more
complicated syntax.
--
Scott Luebking
{mtxinu,sun,pyramid,pacbell}!sybase!scottl
scottl@sybase.com