Exhibit 1014 – Part 6
`
`Exhibit 1014 — Part 6
`
`

`
`156
`
`Chapter 4
`
`Command Languages
`
`replication is necessary to validate whether the results are consistent when
`users must remember and type commands. Factors influencing the results
`may be the relative number of commands and objects and the familiarity the
`user has with each.
`
`Finally, pilot studies by James Foley at George Washington University
`suggest that object first may be more appropriate when using selection by
`pointing on graphic displays is used. Different thinking patterns may be
`engaged when users are faced with visually oriented interfaces (right brain)
`and when they use syntax—oriented command notations (left brain). The
`object-first approach also fits conveniently with the strategy of leaving an
`object selected (and highlighted) after an action is complete, so that, if the
`same object is used in the next action, it is already selected.
`
`4.4.2
`
`Symbols versus keywords
`
`Further evidence that command structure affects performance comes from a
`comparison of 15 commands in a commercially used symbol-oriented text
`editor, and revised commands that had a more keyword-oriented style
`(Ledgard et al., 1980). Here are three sample commands:
`
`Symbol editor
`FIND:/TOOTH/;*l
`LIST;1O
`
`RS:/KO/,/OK/;*
`
`Keyword editor
`BACKWARD TO “TOOTH”
`
`LIST 10 LINES
`CHANGE ALL “K0” T0 “OK”
`
`The revised commands performed the same functions. Single-letter abbre-
`viations (L; 1 0 or L 1 O L) were permitted in both editors, so the number of
`keystrokes was approximately the same. The difference in the revised
`commands was that keywords were used in an intuitively meaningful way,
`but there were no standard rules of formation. Eight subjects at three levels
`of text—editor experience used both versions in this counterbalanced order
`within—subjects design.
`The results (Table 4.1) clearly favored the keyword editor, indicating that
`command—formation rules do make a difference. Unfortunately, no specific
`guidelines emerged except that we should avoid using unfamiliar symbols
`for new users of a given text editor, even if the users are experienced with
`other text editors. It is interesting that the difference in percentage of task
`completed between the symbol and keyword editor was small for the
`experienced users. One conjecture, supported in other studies,
`is that
`experienced computer users develop skill in dealing with strange notations
`and therefore are less affected by syntactic variations.
`
`

`
`4.4 The Benefits of Structure
`
`157
`
`Table 4.1
`
`Impact of revised text—editor commands on three levels of users. (Source: Ledgard
`et al., 1980.)
`
`Percentage of
`Task Completed
`
`Percentage of
`Erroneous Commands
`
`Users
`
`Symbol
`
`Keyword
`
`Symbol
`
`Keyword
`
`Inexperienced
`Familiar
`Experienced
`
`28
`43
`74
`
`42
`62
`84
`
`19
`18
`9.9
`
`1 1
`6.4
`5.6
`
`4.4.3 Hierarchical structure and congruence
`
`Carroll (1982) altered two design variables to produce four versions of a 16-
`command language for controlling a robot (Table 4.2). Commands could be
`hierarchical (Verb—object—qualifier) or nonhierarchical (verb only) and con-
`gruent (for example, ADVANCE / RETREAT or RIGHT / LEFT) or noncongruent
`(GO/ BACK or TURN / LEFT). Carroll uses congruent to refer to meaningful
`pairs of opposites (symmetry might be a better term). Hierarchical structure
`and congruence have been shown to be advantageous in psycholinguistic
`experiments. Thirty-two undergraduate subjects studied one of the four
`command sets in a written manual, gave subjective ratings, and then carried
`out paper-and-pencil tasks.
`Subjective ratings prior to performing tasks showed that subjects disap-
`proved of the nonhierarchical noncongruent form, and gave the highest
`rating for the nonhierarchical congruent form. Memory and problem-
`solving tasks showed that congruent forms were clearly superior, and that
`the hierarchical forms were superior for several dependent measures. Error
`rates were dramatically lower for the congruent hierarchical forms.
`This study assessed performance of new users of a small command
`language. Congruence helped subjects to remember the natural pairs of
`concepts and terms. The hierarchical structure enabled subjects to master 16
`commands with only one rule of formation and 12 keywords. With a larger
`command set—say, 60 or 160 commands—the advantage of hierarchical
`structure should increase, assuming that a hierarchical structure could be
`found to accommodate the full set of commands. Another conjecture is that
`retention should be facilitated by the hierarchical structure and congruence.
`Carroll's study was conducted during a half-day period; with 1 week of
`regular use, differences probably would be reduced substantially. However,
`with intermittent users or with users under stress, the hierarchical congruent
`form might again prove superior. An online experiment might have been
`more realistic and would have brought out differences in command length
`
`

`
`158
`
`Chapter 4
`
`Command Languages
`
`Table 4.2
`
`Command sets and partial results. (Source: Carroll 1982.)
`
`Congruent
`
`Noncongruent
`
`Hierachical
`MOVE ROBOT FORWARD
`MOVE ROBOT BACKWARD
`MOVE ROBOT RIGHT
`MOVE ROBOT LEFT
`MOVE ROBOT UP
`MOVE ROBOT DOWN
`MOVE ARM FORWARD
`MOVE ARM BACKWARD
`MOVE ARM RIGHT
`MOVE ARM LEFT
`MOVE ARM UP
`MOVE ARM DOWN
`CHANGE ARM OPEN
`CHANGE ARM CLOSE
`CHANGE ARM RIGHT
`CHANGE ARM LEFT
`
`N on-
`hierarchical
`ADVANCE
`RETREAT
`RIGHT
`LEFT
`STRAIGHTEN
`BEND
`PUSH
`PULL
`SWING OUT
`SWING IN
`RAISE
`LOWER
`RELEASE
`TAKE
`SCREW
`UNSCREW
`
`Hierachical
`MOVE ROBOT FORWARD
`CHANGE ROBOT BACKWARD
`CHANGE ROBOT RIGHT
`MOVE ROBOT LEFT
`CHANGE ROBOT UP
`MOVE ROBOT DOWN
`CHANGE ARM FORWARD
`MOVE ARM BACKWARD
`CHANGE ARM RIGHT
`MOVE ARM LEFT
`MOVE ARM UP
`CHANGE ARM DOWN
`CHANGE ARM OPEN
`MOVE ARM CLOSE
`MOVE ARM RIGHT
`CHANGE ARM LEFT
`
`Non-
`hierarchical
`GO
`BACK
`TURN
`LEFT
`UP
`BEND
`POKE
`PULL
`PIVOT
`SWEEP
`REACH
`DOWN
`UNHOOK
`GRAB
`SCREW
`TWIST
`
`Subjective Ratings (1 = Best, 5 : Worst)
`1.86
`14.88
`0.50
`2.00
`
`Test 1
`Problem 1 errors
`Problem 1 omissions
`
`1.63
`14.63
`2.13
`2.50
`
`1.81
`7.25
`4.25
`4.75
`
`2.73
`11.00
`1.63
`4.15
`
`that would have been a disadvantage to the hierarchical forms because of the
`greater number of keystrokes required. However, the hierarchical forms could
`all be replaced with three-letter abbreviations (for example, MAL for
`MOVE ARM LEF T), thereby providing an advantage even in keystroke counts.
`
`4.4.4 Consistency, congruence, and mnemonicity
`
`An elegant demonstration of the importance of structuring principles comes
`from a study of four command languages for text editing (Green and Payne,
`1984). Language L4 (Figure 4.6) is a subset of the commercial word processor
`based on the EMACS editor, but it uses several conflicting organizing
`principles. The authors simplified language L3 by using only the CTRL key,
`and using congruence and mnemonic naming where possible. Language L2
`uses CTRL to mean forward and META to mean backward, but mnemonicity is
`sacrificed. Language L1 uses the same meaningful structure for CTRL and
`META, congruent pairs, and mnemonicity.
`
`

`
`4.4 The Benefits of Structure
`
`159
`
` 'm:
`L4
`L3
`L2
`L1
`CTRL—A
`META—A
`CTRL-B
`META—B
`CTRL—C
`META—C
`CTRL-D
`META-D
`CTRL—E
`META-E
`CTRL-F
`META-G
`CTRL-H
`CTRL-I
`CTRL-]
`META-I
`CTRL-K
`META-K
`CTRL-L
`META—L
`CTRL—M
`META-M
`CTRL—N
`META-N
`CTRL-O
`META-O
`
`CTRL-]
`CTRL-l
`CTRL-)
`CTRL-(
`CTRL-V
`CTRL-~"
`CTRL—N
`CTRL-F
`CTRL-l
`CTRL-I
`CTRL-Y
`CTRL-U
`CTRL-S
`CTRL-K
`CTRL-D
`CTRL-DEL
`CTRL—X
`CTRL-W
`CTRL-F
`CTRL—B
`CTRL-~>
`CTRL-~<
`CTRL-Z
`CTRL-A
`CTRL-S
`CTRL-R
`
`META—]
`META-[
`META—B
`META-A
`CTRL-V
`META-V
`CTRL—N
`CTRL-F
`META-F
`META-B
`CTRL-L
`CTRL-G
`META-K
`CTRL-K
`CTRL-D
`CTRL-DEL
`META-D
`META-DEL
`CTRL-F
`CTRL-B
`META—~>
`META—~<
`CTRL—E
`CTRL—A
`CI‘RL—S
`CTRL-K
`
`move pointer forward a paragraph
`move pointer backward a paragraph
`move pointer forward a sentence
`move pointer backward a sentence
`view next screen
`view previous screen
`move pointer to next line
`move pointer to previous line
`move pointer forward a word
`move pointer backward a word
`redisplay screen
`undo last command
`kill sentence forward
`kill line
`delete character forward
`delete character backward
`delete word forward
`delete word backward
`move pointer forward a character
`move pointer backward a character
`move pointer to end of file
`move pointer to beginning of file
`move pointer to end of line
`move pointer to beginning of line
`forward string search
`reverse string search
`
`CTRL-l
`META-[
`CTRL-S
`META-S
`CTRL-V
`META-V
`CTRL-<
`META-<
`CTRL-W
`META—W
`CTRL—R
`META-G
`CTRL-Z
`CTRL-K
`CTRL-D
`META-D
`CTRL-DEL
`META-D
`CTRL-C
`META—C
`CTRL-F
`META—F
`CTRL-L
`META—L
`CTRL—X
`META-X
`
`Figure 4.6
`
`The four languages used in the study discussed in the text. (Green, T. R. G. and Payne,
`S. ]., ”Organization and learnability in computer languages," International Ioumal of Man-
`Machine Studies 21 (1984) 7-18. Used by permission of Academic Press Inc. [London]
`Limited.)
`
`Forty undergraduate subjects with no word-processing experience were
`given 12 minutes to study one of the four languages (Figure 4.6). Then, they
`were asked to recall and write on paper as many of the commands as
`possible. This step was followed by presentation of the command descrip-
`tions, after which they were asked to write down the associated command
`syntax. The free-recall and prompted-recall tasks were both repeated. The
`results showed a statistically significant difference for languages, with
`subjects using L4 demonstrating the worst performance. The best perfor-
`mance was attained with Li, which has the most structure. An online test
`would have been a useful followup to demonstrate the advantage obtained
`with practice and over a longer period.
`
`

`
`160
`
`Chapter 4
`
`Command Languages
`
`In summary, sources of structure that have proven advantageous include
`these:
`
`0 Positional consistency
`0 Grammatical consistency
`0 Congruent pairing
`- Hierarchical form
`
`In addition, as discussed in the next section, a mixture of rneaningfulness,
`mnernonicity, and distinctiveness is helpful,
`One remaining form of structure is visual or perceptual form. The up- and
`down-arrows are highly suggestive of function, as are characters such as
`right— and left-angle brackets,
`the plus sign, and the ampersand.
`WORDSTAR takes advantage of a perceptual clue embedded in the
`QWERTY keyboard layout:
`
`E X
`
`CTRL—E moves the cursor up one line, CTRL-X moves the cursor down
`one line, CTRL-S moves the cursor one character left, CTRL-D moves the
`cursor one character right, CTRL—A moves the cursor one word left, and
`CTRL—F moves the cursor one word right. Other word processors use a
`similar principle with the CTRL—W, A, S, and Z keys or the CTRL-1,], K, and
`M keys.
`
`_?::_
`
`4.5 Naming and Abbreviations
`
`In discussing command-language names, Schneider (1984) takes a delightful
`quote from Shakespeare's Romeo and Iuliet: ”A rose by any other name would
`smell as sweet.” As Schneider points out, the lively debates in design circles
`suggest that this concept does not apply to command-language names.
`Indeed, the command names are the most visible part of a system and are
`likely to provoke complaints from disgruntled users.
`Critics (Norman, 1981, for example) focus on the strange names in UNIX,
`such as MKD IR (make directory), CD (change directory), LS (list directory),
`RM (remove file), and PWD (print working directory); or in IBM's CMS, such
`as S0 (temporarily suspend recording of trace information), LKED (link edit),
`NUCXMAP (identify nucleus extensions), and GENDIRT (generate directory).
`Part of the concern is the inconsistent abbreviation strategies that may take
`the first few letters, first few consonants, first and last letter, or first letter of
`
`

`
`4.5 Naming and Abbreviations
`
`161
`
`each word in a phrase. Worse still are abbreviations with no perceivable
`pattern.
`
`4.5.1
`
`Specificity versus generality
`
`Names are important for learning, problem solving, and retention over time.
`With only a few names, a command set is relatively easy to master; but with
`hundreds of names, the choice of meaningful, organized sets of names
`becomes more important. Similar results were found for programming tasks,
`where variable name choices were less -important in small modules with
`from 10 to 20 names than in longer modules with dozens or hundreds of
`names.
`
`In a word—processing training session (Landauer et al., 1983), 121 students
`learned one of three command sets containing only three commands: the old
`set (delete, append, substitute), a new supposedly improved set
`(omit, add, change), and a random set designed to be confusing (allege,
`ciphe r, deliberate). Task performance times were essentially the same
`across the three command sets, although subjective ratings indicated a
`preference for the old set. The random names were highly distinctive and the
`mismatch with function may have been so disconcerting as to become
`memorable. These results apply to only small command sets.
`With larger command sets, the names do make a difference, especially if
`they support congruence or some other meaningful structure. One naming-
`rule debate revolves around the question of specificity versus generality
`(Rosenberg, 1982). Specific terms can be more descriptive, and if they are
`more distinctive, they may be more memorable. General terms may be more
`familiar and therefore easier to accept. Two weeks after a training session
`with 12 commands, subjects were more likely to recall and recognize the
`meaning of specific commands than of general commands (Barnard et al.,
`1982).
`In a paper—and—pencil test, 84 subjects studied one of seven sets of eight
`commands (Black and Moran, 1982). Two of the eight commands—the
`commands for inserting and deleting text—are shown here in all seven
`versions:
`
`Infrequent, discriminating words
`Frequent, discriminating words
`Infrequent, nondiscriminating words
`Frequent, nondiscriminating words
`General words (frequent, nondiscriminating)
`Nondiscriminating nonwords (nonsense)
`
`i n s e rt
`add
`amb l e
`wa l k
`a l t e r
`GAC
`
`de 1 et e
`1:‘ emove
`p e r ce i ve
`vi ew
`c 0 rr e c t
`MIK
`
`Discriminating nonwords (icons)
`
`a be — adbc
`
`ab c — ac
`
`g
`
`A
`
`

`
`162
`
`Chapter 4
`
`Command Languages
`
`The ”infrequent, discriminating" command set resulted in faster learning
`and superior recall than did other command sets. The general words were
`correlated with the lowest performance on all three measures. The non-
`sense words did surprisingly well, supporting the possibility that, with
`small command sets, distinctive names are helpful even if they are not
`meaningful.
`
`4.5.2 Abbreviation strategies
`
`Even though command names should be meaningful for human learning,
`problem solving, and retention, they must satisfy another important crite-
`rion. They must be in harmony with the mechanism for expressing the
`commands to the computer. The traditional and widely used command-
`entry mechanism is the keyboard, which indicates that commands should
`use brief and kinesthetically easy codes. Commands requiring shifted keys
`or CTRL keys, special characters, or difficult sequences are likely to cause
`higher error rates. For text editing, when many commands are applied and
`speed is appreciated, single-letter approaches are attractive. Overall, brevity
`is a worthy goal since it can speed entry and reduce error rates. Many word-
`processor designers have pursued this approach, even when mnemonicity
`was sacrificed, thereby making use more difficult for novice and intermittent
`users.
`
`In less demanding applications, designers have used longer command
`abbreviations, hoping that the gains in recognizability would be appreciated
`over the reduction in key strokes. Novice users may actually prefer typing
`the full name of a command because they have a greater confidence in its
`success (Landauer et al., 1983). Novices who were required to use full
`command names before being taught two-letter abbreviations made fewer
`errors with the abbreviations than those who were taught the abbreviations
`from the start and than did those who could create their own abbreviations
`(Grudin and Barnard, 1985).
`
`The phenomenon of preferring the full name at first appeared in our
`study of bibliographic retrieval with the Library of Congress's SCORPIO
`system. Novices preferred typing the full name, such as BROWSE or SELECT,
`rather than the traditional four-letter abbreviations BRWS or SLCT, or the
`single-letter abbreviations B or S. After five to seven uses of the command,
`their confidence increased and they attempted the single-letter abbrevia-
`tions. A designer of a text adventure game recognized this principle and
`instructs novice users to type EAST, WEST, NORTH, or SOUTH; after five full-
`length commands, the system tells the user about the single-letter abbrevia-
`tions. A related report comes from some users of IBM's CMS, who find that
`the minimal length abbreviations are too difficult to learn; they stick with the
`full form of the command.
`
`

`
`4.5 Naming and Abbreviations
`
`163
`
`With experience and frequent use, abbreviations become attractive for,
`and even necessary to satisfy, the ”power” user. Efforts have been made to
`find optimal abbreviation strategies. Several studies support the notion that
`abbreviation should be made by a consistent strategy (Ehrenreich and Porcu,
`1982; Benbasat and Wand, 1984; Schneider, 1984). Here are six potential
`strategies:
`1. Simple truncation: Use the first, second, third, etc. letters of each command.
`This strategy requires that each command be distinguishable by the
`leading string of characters. Abbreviations can be all of the same length or
`of different lengths.
`. Vowel drop with simple truncation: Eliminate vowels and use some of what
`remains. If the first letter is a vowel, it may or may not be retained. H, Y,
`and W may or may not be considered as vowels.
`. First and last letter: Since the first and last letters are highly visible, use
`them; for example, use ST for SORT.
`. First letter of each word in a phrase: Use this popular technique, for example,
`with a hierarchical design plan.
`. Standard abbreviations from other contexts: Use familiar abbreviations such
`as QTY for QUANTITY, XTALK for CROSSTALK (a software package), PRT
`for PRINT, or BAK for BACKUP.
`
`6. Phonics: Focus attention on the sound; for example, use XQT for execute.
`Truncation appears to be the most effective mechanism overall, but it has
`its problems. Conflicting abbreviations appear often, and decoding of an
`unfamiliar abbreviation is not as easy as when vowel dropping is used
`(Schneider, 1984).
`
`4.5.3 Guidelines for using abbreviations
`
`Ehrenreich and Porcu (1982) offer this compromise set of guidelines:
`
`1. A simple, primary rule should be used to generate abbreviations for most
`items; a simple secondary rule should be used for those items where there
`is a conflict.
`
`. Abbreviations generated by the secondary rule should have a marker (for
`example, an asterisk) incorporated in them.
`. The number of words abbreviated by the secondary rule should be kept to
`a minimum.
`
`4. Users should be familiar with the rules used to generate abbreviations.
`. Truncation is an easy rule for users to comprehend, but it may also
`produce a large number of identical abbreviations for different words.
`. Use fixed-length abbreviations in preference to variable-length ones.
`
`

`
`164
`
`Chapter 4
`
`Command Languages
`
`7. Abbreviations should not be designed to incorporate endings (e.g., ING,
`ED, s).
`
`8. Unless there is a critical space problem, abbreviations should not be used
`in messages generated by the computer and read by the user.
`
`Abbreviations are an important part of system design and they are
`appreciated by experienced users. Users are more likely to use abbreviations
`if they are confident in their knowledge of the abbreviations and if the
`benefit is a savings of more than one to two characters (Benbasat and Wand,
`1984). The appearance of new input devices and strategies (for example,
`selecting by pointing) will change the criteria for abbreviations. Each
`situation has its idiosyncrasies and should be evaluated carefully by the
`designer, applying empirical tests where necessary.
`
`4.6 Command Menus
`
`To relieve the burden of memorization of commands, some designers offer
`users brief prompts of available commands. The early online version of the
`Official Airline Guide used such prompts as this:
`
`ENTER +,L#,X#, S#, R#,M,RF (#=LINE NUMBER)
`
`This prompt reminds users of the commands related to fares that have
`been displayed, and the related flight schedules:
`
`+
`L#
`
`X#
`S #
`
`R#
`M
`
`RF
`
`move forward one screen
`limitations on airfares
`
`detailed information on a listed flight
`schedule information for the listed fare
`
`return flight information for this route
`main menu
`
`return fares
`
`Experienced users come to know the commands and do not need to read
`the prompt or the help screens. Intermittent users know the concepts and
`refer to the prompt to jog their memory and to get help in retaining the
`syntax for future uses. Novice users do not benefit as much from the prompt
`and must take a training course or consult the online help.
`The prompting approach emphasizes syntax and serves frequent users. It
`is closer to but more compact than a standard numbered menu, and
`preserves screen space for task-related information. The early WORDSTAR
`
`

`
`4.6 Command Menus
`
`165
`
`INSERT UN
`PAGE 1 LINE 9 COL 62
`A:GETTVS
`M E N U
`>
`>
`>
`<
`< (
`M A I N
`--Cursor Movement--
`l —DeIete— : —Miscel1aneou5-
`: —Dther Menus-
`char
`left ‘D char right
`l‘G char
`E “I Tab
`‘B Reform i
`(from Main only)
`word left ‘F word right
`{DEL chr If:
`“V INSERT DN/OFF
`:‘J Help
`“K Block
`line up
`“X line down
`{AT word rtI*L Find/Replce againl“D Duick "P Print
`——Scra1]ing--
`IRETURN End paragraphX“U Dnscreen
`line down ‘N line
`1 “N Insert a RETURN
`screen up ‘R screen down
`i
`‘U Stop a command
`L-—--9----!——-—!----!----!--—-!--—-!----!—---!————!————! ————————R
`Fourscure
`and seven years ago our fathers brought forth on
`this continent a new nation Conceived in liberty and dedicated to
`the proposition that all men are created equal.
`Now we
`are
`engaged in a great civil war testing whether that nation.
`or any
`nation en conceived and so dedicated, can long endure.
`We are met on a great battlefield of that war.
`He have come
`to dedicate a portion of that field as a final resting-place for
`those who here gave their lives that
`that nation might live.
`
`Figure 4.7
`
`The early Wordstar offered the novice and intermittent users help menus
`containing commands with one- or two—worcl descriptions.
`
`editor offered the novice and intermittent user help menus containing
`Commands with one- or two-word descriptions (Figure 4.7). Frequent users
`could turn off the display of help menus, thereby gaining screen space for
`additional text.
`
`Several interactive systems on personal computers have another, still
`more attractive form of prompts called command menus. Users are shown a
`list of descriptive words and make a selection by pressing the left and right
`arrow keys to move a light bar. When the desired command word is
`highlighted, the user presses the return key to carry out the command.
`Often, the command menu is a hierarchical structure that branches to a
`second- or third—level menu.
`
`Even though arrow-key movement is relatively slow and is not preferred
`by frequent users, command-menu items can be selected by single-letter
`keypresses. This strategy becomes a hierarchical command language; it is
`identical to the typeahead (BLT) approach of menu selection. Novice users
`can use the arrow keys to highlight their choice, or can type single-letter
`choices, but frequent users do not even look at the menus as they type
`sequences of two, three, four, or more single letters that come to be thought
`of as a command (Figure 4.5).
`The Lotus 1-2-3 (Figure 4.8) implementation is especially fast and elegant.
`As command words are selected, a brief description appears on the line
`below, providing further assistance for novice users without distracting
`experts from their concentration on the task. Experienced users appear to
`work as fast as touch typists, making three to six keystrokes per second.
`Pop-up or pull-down menus that use mouse selection constitute another
`form of command menu. Frequent users can work extremely quickly, and
`novices can take the time to read the choices before selecting a command.
`
`

`
`166
`
`Chapter 4
`
`Command Languages
`
`wnrkshert Range Cnnv Move File Print. Graph Data
`
`[link
`No Yes
`Fin Yable
`sun auerv Dsstrmute
`Type xaacoss Reset View Save Clptlufls Name nun
`Pflflt F)la
`aeuawe, saw. cumume. Xtrant, Erase. Lust.
`
`impart. Directory
`
`i
`
`Blcmal.
`
`rarvueofCells)EnterrangeFWD":
`(Moveacellor
`
`(Copyacellorrangeofcells)Entarrangemom
`
`Formab Lanel4Praf'ix. Erase, Name, JustiYyy Frntectv Unprotectu Input
`Insert. Delntsg Culumn-Llirflchu Erase. vines. Lnnduw. Status
`
`Figure 4.8
`The first two levels of command menus from LOTUS 1-2-3 reveal the rich function
`available to users. At the third level, users may receive another menu or enter values.
`(Printed with permission of Lotus Development Corporation, Cambridge, MA.)
`
`With a fast display, command menus blur the boundaries between com-
`mands and menus.
`
`4.7 Natural Language in Computing
`
`Even before there were computers, people dreamed about creating machines
`that would accept natural language. It is a wonderful fantasy, and the success
`of word-manipulation devices such as word processors, printing presses,
`tape recorders, and telephones may give encouragement to some people.
`Although there has been some progress in machine translation from one
`natural language to another (for example, Japanese to English), most effec-
`tive systems require constrained or preprocessed input, or postprocessing of
`output. Undoubtedly, improvements will continue and constraints will be
`reduced, but high-quality reliable translations of complete documents with-
`out human intervention seems difficult to attain. Structured texts such as
`
`weather reports are translatable; technical papers are marginally translat-
`able; novels or poems are not translatable. Language is subtle; there are
`many special cases, meaning is not easily programmed into machines, and
`context has a powerful and pervasive effect.
`Although full comprehension and generation of language seems inacces-
`sible, there are still many ways that computers can be used in dealing with
`natural language, such as for interaction, queries, database searching, text
`generation, and adventure games. So much research has been invested in
`natural-language systems that undoubtedly some successes will emerge, but
`widespread use may not develop because the alternatives may be more
`appealing. More rapid progress can be made if carefully controlled experi-
`
`

`
`4.7 Natural Language in Computing
`
`167
`
`mental tests are used to discover the designs, users, and tasks for which
`natural—language applications are most beneficial.
`
`4.7.1 Natural-language interaction
`
`Researchers hope that someday computers will respond easily to commands
`users issue by typing or speaking in natural language. Natural-language
`interaction (NLI) might be defined as the operation of computers by people
`using a familiar natural language (such as English) to give instructions and
`receive responses. Users do not have to learn a command syntax or to select
`from menus. Early attempts at generalized “automatic programming” have
`faded, but there are continuing efforts to provide domain-specific assistance.
`The problems with NLI lie in not only implementation on the computer,
`but also desirability for large numbers of users for a wide variety of tasks.
`People are different from computers, and human—human interaction is not
`necessarily an appropriate model for human operation of computers. Since
`computers can display information 1000 times faster than people can enter
`commands, it seems advantageous to use the computer to display large
`amounts of information, and to allow novice and intermittent users simply
`to choose among the items. Selection helps to guide the user by making clear
`what functions are available. For knowledgeable and frequent users, who
`are thoroughly aware of the available functions, a precise, concise command
`language is usually preferred.
`In fact, the metaphors of artificial intelligence (smart machines, intelligent
`agents, and expert systems) may prove to be mind—1imiting distractions that
`inhibit designers from creating the powerful tools that become commercially
`successful. Spreadsheets, WYSIWYG word processors, and direct—manipula-
`tion graphics tools emerged from a recognition of what users were using
`effectively, rather than from the misleading notions of intelligent machines.
`Similarly, the next generation of groupware to support collaboration, visual-
`ization and simulation packages, tele-operated devices, and hypermedia
`stem from user-centered scenarios, rather than the machine-centered artifi-
`cial-intelligence fantasies.
`The SSOA model can help us to sort out the issues. NLI does not provide
`information about actions and objects in the task domain; users are usually
`presented with a simple prompt that invites a natural-language query. But
`the user may be knowledgeable about the task domain—for example, about
`the meaning of database objects and permissible actions. NLI also does not
`necessarily convey knowledge of the computer concepts—for example, tree-
`structuring of information, implications of a deletion, Boolean operations, or
`query strategies. NLI does relieve the user of learning new syntactic rules,
`since it presumably will accept familiar English language requests. There-
`fore, NLI can be effective for the user who is knowledgeable about some task
`
`L
`
`I.
`
`

`
`168
`
`Chapter 4
`
`Command Languages
`
`domain and computer concepts but who is an intermittent user who cannot
`retain the syntactic details. Lately, some members of the artificial-intellr
`gence community have understood the power of direct manipulation for
`conveying the system state and suggesting possible actions, and have
`attempted to blend visual presentation of status with natural-language
`input.
`NLI might apply to checkbook maintenance (Shneiderman, 1980), where
`the users recognize that there is an ascending sequence of integer—numbered
`checks, and that each check has a single payee field, single amount, single
`date, and one or more signatures. Checks can be issued, voided, searched,
`and printed. In fact, following this suggestion, Ford (1981) created and tested
`an NLI system for this purpose. Subjects were paid to maintain their
`checkbook registers by computer using an APL—based program that was
`incrementally refined to account for unanticipated entries. The final system
`successfully handled 91 percent of users’ requests, such as these:
`
`Pay to Safeway on 3/24/86 $29.75.
`June 10 $33.00 to Madonna.
`Show me all the checks paid to George Bush.
`Which checks were written on October 29?
`
`Users reported satisfaction with the system and were eager to use the
`system even after completing the several months of experimentation. This
`study can be seen as a success for NLI, but alternatives might be even more
`attractive. Showing a full screen of checkbook entries with a blank line for
`new entries might accomplish most tasks without any commands and with
`minimal typing (similar to what is used in Quicken from Intuit). Users could
`do searches by entering partial information (for example, George Bush in
`the payee field) and then pressing a query key.
`There have been numerous informal tests of NLI systems, but only a few
`have been experimental comparisons against some other design. Research-
`ers seeking to demonstrate the advantage of NLI over command-language
`and menu approaches for creating business graphics were surprised to find
`no significant differences for time, errors, or attitude (Hauptmann and
`Green, 1983).
`A more positive result was found with users of HAL, the restricted
`natural-language addition to Lotus 1-2-3 (Napier et al., 1989). HAL users
`Could avoid the command-menu / WEY (for Worksheet Erase Yes), and could
`type requests such as \erase worksheet, \insert row, or \total all
`columns, starting with any of the 180 permissible verbs. In an empirical
`study, after 1.5 days of training, 19 HAL users and 22 Lotus 1-2-3 users
`worked on three substantial problem sets for another 1.5 days. Performance
`and preference strongly favored the restricted natural language version, but
`the experimenters had difficulty identifying the features that made a differ-
`
`

`
`4.7 Natural Language in Computing
`
`169
`
`ence: ”It is not clear whether Lotus HAL was better because it is more like
`
`English or because it takes advantage of context, but we suspect the latter is
`more important." By context, the authors meant features such as the cursor
`position or meaningful variable names that indicate cell ranges.
`Some NLI work has turned to automatic speech recognition and speech
`generation to reduce the barriers to acceptance. There is some advantage to
`use of these technologies, but the results are still meager. A promising