File size: 50,300 Bytes
6fa4bc9 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 |
{
"paper_id": "A00-1015",
"header": {
"generated_with": "S2ORC 1.0.0",
"date_generated": "2023-01-19T01:12:24.026319Z"
},
"title": "J avox: A Toolkit for Building Speech-Enabled Applications",
"authors": [
{
"first": "Michael",
"middle": [
"S"
],
"last": "Fulkerson",
"suffix": "",
"affiliation": {
"laboratory": "",
"institution": "Duke University Durham",
"location": {
"postCode": "27708",
"region": "North Carolina",
"country": "USA"
}
},
"email": ""
},
{
"first": "Alan",
"middle": [
"W"
],
"last": "Biermann",
"suffix": "",
"affiliation": {
"laboratory": "",
"institution": "Duke University Durham",
"location": {
"postCode": "27708",
"region": "North Carolina",
"country": "USA"
}
},
"email": ""
}
],
"year": "",
"venue": null,
"identifiers": {},
"abstract": "JAVOX provides a mechanism for the development of spoken-language systems from existing desktop applications. We present an architecture that allows existing Java 1 programs to be speech-enabled with no source-code modification, through the use of reflection and automatic modification to the application's compiled code. The grammars used in JAvox are based on the Java Speech Grammar Format (JSGF); JAVOX grammars have an additional semantic component based on our JAVOX Scripting Language (JSL). JAVOX has been successfully demonstrated on real-world applications.",
"pdf_parse": {
"paper_id": "A00-1015",
"_pdf_hash": "",
"abstract": [
{
"text": "JAVOX provides a mechanism for the development of spoken-language systems from existing desktop applications. We present an architecture that allows existing Java 1 programs to be speech-enabled with no source-code modification, through the use of reflection and automatic modification to the application's compiled code. The grammars used in JAvox are based on the Java Speech Grammar Format (JSGF); JAVOX grammars have an additional semantic component based on our JAVOX Scripting Language (JSL). JAVOX has been successfully demonstrated on real-world applications.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Abstract",
"sec_num": null
}
],
"body_text": [
{
"text": "1 Overview JAVOX is an implemented set of tools that allows software developers to speech-enable existing applications. The process requires no changes to the program's source code: Speech capacity is pluggedin to the existing code by modifying the compiled program as it loads. JAVOX is intended to provide similar functionality to that usually associated with menus and mouse actions in graphical user interfaces (GUIs). It is completely programmable -developers can provide a speech interface to whatever functionality they desire. Jivox has been successfully demonstrated with several GUI-based applications.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "Previous systems to assist in the development of spoken-langnage systems (SLSs) have focused on building stand-alone, customized applications, such as (Sutton et al., 1996) and (Pargellis et al., 1999) . The goal of the JAVOX toolkit is to speech-enable traditional desktop applications -this is similar to the goals of the MELISSA project (Schmidt et al., 1998) . It is intended to both speed the development of SLSs and to localize the speech-specific code within the application. JAVOX allows developers to add speech interfaces to applications at the end of the development process; SLSs no longer need to be built from the ground up.",
"cite_spans": [
{
"start": 151,
"end": 172,
"text": "(Sutton et al., 1996)",
"ref_id": "BIBREF5"
},
{
"start": 177,
"end": 201,
"text": "(Pargellis et al., 1999)",
"ref_id": "BIBREF2"
},
{
"start": 340,
"end": 362,
"text": "(Schmidt et al., 1998)",
"ref_id": "BIBREF3"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "We will briefly present an overview of how JAVOX works, including its major modules. First, we 1Java and Java Speech are registered trademarks of Sun Microsystems, Inc.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "will examine TRANSLATOR, the implemented JAVOX natural language processing (NLP) component; its role is to translate from natural language utterances to the JhVOX Scripting Language (JSL). Next, we will discuss JSL in conjunction with a discussion of EXECUTER, the interface between JAVOX and the application. We will explain the JhvOX infrastructure and its current implementation in Java. In conclusion, we will discuss the current state of the project and where it is going.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "Basic Operation Jivox can be used as the sole location of NLP for an application; the application is written as a nonspeech-enabled program and JhvOX adds the speech capability. The current implementation is written in Java and works with Java programs. The linkage between the application program and JhvOX is created by modifying -at load time -all constructors in the application to register new objects with JAVOX. For this reason, the application's source code does not need any modification to enable JAVOX. A thorough discussion of this technique is presented in Section 4. The schematic in Figure 1 shows a high-level overview of the JAVOX architecture.",
"cite_spans": [],
"ref_spans": [
{
"start": 598,
"end": 606,
"text": "Figure 1",
"ref_id": "FIGREF1"
}
],
"eq_spans": [],
"section": "2",
"sec_num": null
},
{
"text": "Issuing a voice command begins with a user utterance, which the speech recognizer processes and passes to the NLP component, TRANSLATOR. We are using the IBM implementation of Sun's Java Speech application program interface (API) (Sun Microsystems, Inc., 1998) in conjunction with IBM's VIAVOICE. The job of TRANSLATORor a different module conforming to its API -is to translate the utterance into a form that represents the corresponding program actions. The current implementation of TRANSLATOR uses a context-free grammar, with each rule carrying an optional JSL fragment. A typical bottom-up parser processes utterances and a complete JSL program results. The resulting JSL is forwarded to EXECUTER, where the JSL code is executed. For example, in a hypothetical banking application, the utterance add $100 to the account might be translated into the JSL command: myBalance = myBalance + i00; The job of EXECUTER -or a different module that conforms to EXECUTER'S API -is to execute and monitor upcalls into the running application. The upcalls are the actual functions that would be made by the appropriate mouse clicks or menu selections had the user not used speech. For this reason, we are currently concentrating our efforts on event-driven programs, the class of most GUI applications. Their structure is usually amenable to this approach. Our implementation of EXECUTER performs the upcalls by interpreting and executing JSL, though the technology could be used with systems other than JSL. In the banking example, EXECUTER would identify the myBalemce variable and increment it by $100.",
"cite_spans": [
{
"start": 230,
"end": 260,
"text": "(Sun Microsystems, Inc., 1998)",
"ref_id": "BIBREF4"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "2",
"sec_num": null
},
{
"text": "The main JAVOX components, TRANSLATOR and EXECUTER, are written to flexible APIs. Developers may choose to use their own custom components instead of these two. Those who want a different NLP scheme can implement a different version of TRANSLATOR and -as long as it outputs JSLstill use EXECUTER. Conversely, those who want a different scripting system can replace JSL and still use TRANSLATOR and even EXECUTER's low-level infrastructure.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "2",
"sec_num": null
},
{
"text": "The JAVOX infrastructure is not tied to any particular NLP method; in fact, the JAVOX grammar system is the second NLP implementation we have used. It is presented here because it is straightforward, easy to implement, and surprisingly powerful. JAVOX grammars axe based on Sun's Java Speech Grammar Format (JSGF) (Sun Microsystems, Inc., 1998) . JSGF is a rule-based, speech-recognition grammar, designed to specify acceptable input to a recognizer. In JAVOX grammars, each J S G F rule may be augmented with a fragment of JAVOX Scripting Language code -we refer to JAVOX grammars as scriptable grammars. The result of parsing an utterance with a JAVOX grammar is a complete piece of JSL code, which is then interpreted to perform the action specified by the user. The process of speech-enabling an application in JAVOX consists of writing a grammar that contains the language to be used and the corresponding actions to be performed. Building on top of 3SGF means -in many cases -only one file is needed to contain all application-specific information. JSL-specific code is automatically stripped from the grammar at runtime, leaving an ordinary JSGF grammar. This JSGF grammar is sent to a Java-Speech-compliant recognizer as its input grammar. In the current Java implementation, each Java source file (Foo. java) can have an associated JAVOX grammar file (Foo. gram) that contains all the information needed to speak to the application. Encapsulating all natural language information in one file also means that porting the application to different languages is far easier than in most SLSs.",
"cite_spans": [
{
"start": 314,
"end": 344,
"text": "(Sun Microsystems, Inc., 1998)",
"ref_id": "BIBREF4"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "J a v o x G r a m m a r s",
"sec_num": "3"
},
{
"text": "Since JSGF grammars are primarily speechrecognition grammars, they lack the ability to encode semantic information. They only possess a limited tag mechanism. Tags allow the recognizer to output a canonical representation of the utterance instead of the recognition verbatim. For example, public <ACTION> = move [the] <PART> <DIR>; public <PART> = eyes; public <PART> = ( cap I hat ); public <DIR> = up; public <DIR> = down;",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "S e r i p t a b l e G r a m m a r s",
"sec_num": "3.1"
},
{
"text": "Grammar 1: A JSGF fragment from the Mr. Potato Head domain. the tag rm may be the output from both delete the file and remove it.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "S e r i p t a b l e G r a m m a r s",
"sec_num": "3.1"
},
{
"text": "Tags are not implemented in JAVOX grammars; instead, we augment the rules of JSGF with fragments of a scripting language, which contains much richer semantic information than is possible with tags. TRANSLATOR receives the raw utterance from the recognizer and translates it into the appropriate semantic representation. JAvox grammars do not mandate the syntax of the additional semantic portion. Though JSL is presented here, TRANSLATOR has been used to form Prolog predicates and Visual Basic fragments.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "S e r i p t a b l e G r a m m a r s",
"sec_num": "3.1"
},
{
"text": "JSGF rules can be explicitly made public or are implicitly private. Public rules can be imported by other grammars and can serve as the result of a recognition; a private rule can be used in a recognition, but cannot be the sole result. The five rules in Grammar 1 are from a JSGF-only grammar fragment from the Mr. Potato Head 2 domain (discussed later). Grammar 1 allows eight sentences, such as move the eyes up, move the eyes down, move the cap up, move the cap down, and move cap up. Rule names are valid Java identifiers enclosed within angle brackets; the left-hand side (LHS) is everything to the left of the equality sign and the right-hand side (RHS) is everything to the right. JAVOX grammars include the standard constructs available in JSGF, these include: Imports Any grammar file can be imported into other grammar files, though only public rules are exported. This allows for the creation of grammar libraries. When using JSL, Java classes can also be imported.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "S e r i p t a b l e G r a m m a r s",
"sec_num": "3.1"
},
{
"text": "Comments Grammars can be documented using Java comments: single-line comments (//) and delimited ones (/* until */).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "S e r i p t a b l e G r a m m a r s",
"sec_num": "3.1"
},
{
"text": "Alternatives A vertical bar ( I ) can be used to separate alternative elements, as in the <PART> rule of Grammar 1.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Optionals Optional elements are enclosed within brackets ([ and ] ), such as the in Grammar l's <ACTION> rule.",
"cite_spans": [
{
"start": 57,
"end": 65,
"text": "([ and ]",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "2Mr. Potato Head is a registered trademark of Hasbro, Inc.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Kleene Star Operator A postfix Kleene star (*) operator can be used to indicate that the preceding element may occur zero or more times.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Plus Operator A similar operator to indicate that an element may appear one or more times.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "A grammar's rules may be organized however the developer wishes. Some may choose to have one rule per utterance, while others may divide rules to the parts-of-speech level or group them by semantic value. In practice, we tend to write rules grouped by semantic value for nouns and verbs and at the partsof-speech level for function words. Grammar 2 shows the Mr. Potato Head grammar augmented with JSL fragments.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "The semantic component of each rule is separated from the RHS by a colon and delimited with a brace and colon ({: until :}). Using Grammar 2, the parse and translation for Move the cap up is shown in Figure 2 .",
"cite_spans": [],
"ref_spans": [
{
"start": 200,
"end": 208,
"text": "Figure 2",
"ref_id": "FIGREF3"
}
],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Each rule may have either one semantic fragment or any number of named fields. A single fragment is sufficient when there is a one-to-one correlation between a lexical item and its representation in the program. Occasionally, a single lexical item may require several components to adequately express its meaning within a program. In Grammar 2, there is a one-to-one correlation between the direction of movement and the slideUp and slideDown functions in the <DIR> rules. These functions can also written as a single slide function, with the direction of the movement given by two parametric variables (cos and sin). In this situation, the direction rule (<DIR.}/F>) needs to be expressed with two values, each known as a named field. The word up may be represented by the named fields cos and sin, with the values 0 and 1 respectively.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Another issue in JSL -which does not arise in the syntax-only JSGF -is the need to uniquely identify multiple sub-rules of the same type, when they occur in the same rule. For example, in a geometry grammar, two <POINT>s may be needed in a rule to declare a <LINE>, as in:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "public <LINE> = make a line from <POINT> to <POINT> : ...",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "Uniquely numbering the sub-rules eliminates the ambiguity as to which <POINT> is which. Numbering can be used in both the RttS and the semantic portion of a rule; numbering is not allowed in the LHS of a rule. Syntactically, sub-rules are numbered with a series of single quotes3:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "public <LINE> = make a line from <POINT'> to <POINT''> : ...",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Parenthesis Precedence can be modified with parentheses.",
"sec_num": null
},
{
"text": "The JAVOX Scripting Language (JSL) is a standalone programming language, developed for use with the JAVOX infrastructure. JSL can be used to manipulate a running Java program and can be thought of as an application-independent macro language. The EXECUTER module interprets JSL and performs the specified actions. The specifics of JSL are not important to understanding JAVOX; for this reason, only a brief summary is presented here. JSL can read of modify the contents of an object's fields (data members) and can execute methods (member functions) on objects. Unlike Java, JSL is loosely-typed: Type checking is not done until a given method is executed. JSL has its own variables, which can hold objects from the host application; a JSL variable can store an object of any type and no casting is required. JSL supports Java's primitive types, Java's reference types (objects), and Lisp-like lists. Though JSL does support 3This representation is motivated by the grammars of (Hipp, 1992 ). Java's primitive types, they are converted into their reference-type equivalent. For example, an integer is stored as a java. lang. Integer and is converted back to an integer when needed.",
"cite_spans": [
{
"start": 978,
"end": 989,
"text": "(Hipp, 1992",
"ref_id": "BIBREF1"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "J a v o x S c r i p t i n g L a n g u a g e ( J S L )",
"sec_num": "3.2"
},
{
"text": "JSL has the standard control flow mechanisms found in most conventional programming languages, including if-else, for and while loops. With the exception of the evaluation of their boolean expressions, these constructs follow the syntax and behavior of their Java counterparts. Java requires that if-else conditions and loop termination criteria be a boolean value. JSL conditionals are more flexible; in addition to booleans, it evaluates non-empty strings as true, empty strings as false, non-zero values as true, zero as false, non-null objects as true, and n u l l as false.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "J a v o x S c r i p t i n g L a n g u a g e ( J S L )",
"sec_num": "3.2"
},
{
"text": "In addition to Java's control flow mechanisms, JSL also supports f o r e a c h loops, similar to those found in Perl. These loops iterate over both JSL lists and members of java.util.List, executing the associated code block on each item. JSL lists are often constructed by recursive rules in order to handle conjunctions, as seen in Section 5.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "J a v o x S c r i p t i n g L a n g u a g e ( J S L )",
"sec_num": "3.2"
},
{
"text": "The JAVOX infrastructure has been designed to completely separate NLP code from the application's code. The application still can be run without JAVOX, as a typical, non-speech-enabled program -it is only speech-enabled when run with JAVOX.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Infrastructure",
"sec_num": "4"
},
{
"text": "From the application's perspective, JAVOX operates at the systems-level and sits between the application and the operating system (virtual machine), as shown in Figure 1 . TRANSLATOR interfaces with the speech recognizer and performs all necessary NLP. EXECUTER interfaces directly with the application and performs upcalls into the running program. Java has two key features that make it an ideal test platform for our experimental implementation: reflection and a redefineable loading scheme. Reflection provides a running program the ability to inspect itself, sometimes called introspection. Objects can determine their parent classes; every class is itself an object in Java (an instance of j ava.lang.Class). Methods, fields, constructors, and all class attributes can be obtained from a Class object. So, given an object, reflection can determine its class; given a class, reflection can find its methods and fields. JAVOX uses reflection to (1) map from the JSL-textual representation of an object to the actual instance in the running program; (2) find the appropriate j ava.lang.reflect.Methods for an object/method-name combination; and (3) actually invoke the method, once all of its arguments are known.",
"cite_spans": [],
"ref_spans": [
{
"start": 161,
"end": 169,
"text": "Figure 1",
"ref_id": "FIGREF1"
}
],
"eq_spans": [],
"section": "Infrastructure",
"sec_num": "4"
},
{
"text": "Reflection is very helpful in examining the application program's structure; however, prior to using reflection, EXECUTER needs access to the objects in the running program. To obtain pointers to the objects, JAVOX uses JOIE, a load-time transformation tool (Cohen et al., 1998) . JOIE allows us to modify each application class as it is loaded into the virtual machine. The JAVOX transform adds code to every constructor in the application that registers the new object with Executer. Conceptually, the following line is added to every constructor:",
"cite_spans": [
{
"start": 258,
"end": 278,
"text": "(Cohen et al., 1998)",
"ref_id": "BIBREF0"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Infrastructure",
"sec_num": "4"
},
{
"text": "Executer. register (this).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Infrastructure",
"sec_num": "4"
},
{
"text": "This modification is done as the class is loaded, the compiled copy -on disk -is not changed. This allows the program to still be run without JhVOX, as a non-speech application. EXECUTER can -once it has the registered objects -use reflection to obtain everything else it needs to perform the actions specified by the JSL.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Infrastructure",
"sec_num": "4"
},
{
"text": "Our longest running test application has been a Mr. Potato Head program; that allows users to manipulates a graphical representation of the classic children's toy. Its operations include those typically found in drawing programs, to include moving, recoloring and hiding various pieces of Mr. Potato Head. Grammar 3 shows a portion of application's grammar needed to process the utterance Move the eyes and glasses up. The result of parsing this utterance is shown in Figure 3 .",
"cite_spans": [],
"ref_spans": [
{
"start": 468,
"end": 476,
"text": "Figure 3",
"ref_id": "FIGREF4"
}
],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "Once TRANSLATOR has processed an utterance, it forwards the resulting JSL fragment to EXECUTER. Figure 4 provides a reduced class diagram for the Mr. Potato Head application; the arrows correspond to the first iteration in the following trace. The following steps are performed as the JSL fragment from Figure 3 is interpreted:",
"cite_spans": [],
"ref_spans": [
{
"start": 96,
"end": 104,
"text": "Figure 4",
"ref_id": null
},
{
"start": 303,
"end": 311,
"text": "Figure 3",
"ref_id": "FIGREF4"
}
],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "1. A new variable -local to EXECUTER -named $iter is created. Any previously-declared variable with the same name is destroyed.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "2. The foreach loop starts by initializing the loop variable to the first item in the list: Canvas.eyes0bj. This object's name consists of two parts; the steps to locate the actual instance in the application are:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "(a) The first part of the name, Canvas, is mapped to the only instance of the Canvas class in the context of this application. JAVOX has a reference to the instance because it registered with EXECUTER when it was created, thanks to a JOIE transformation.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "(b) The second part of the name, eyes0bj, is found through reflection. Every instance of Canvas has a field named eyes0bj of type BodyPaxt. This field is the eyes0bj for which we are looking.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "3. Once eyes0bj is located, the appropriate method must be found. We determinethrough reflection -that there are two methods in the BodyPart class with the name move, as seen in Figure 4 . 4. We next examine the two arguments and determine them to be both integers. Had the arguments been objects, fields, or other method calls, this entire procedure would be done recursively on each.",
"cite_spans": [],
"ref_spans": [
{
"start": 178,
"end": 186,
"text": "Figure 4",
"ref_id": null
}
],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "5. We examine each possible method and determine that we need the one with two integer arguments, not the one taking a single Point argument.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "6. Now that we have the object, the method, and the arguments, the upcall is made and the method is executed in the application. The result is that Mr. Potato Head's eyes move up on the screen.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "7. This process is repeated for glass0bj and the loop terminates.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "After this process, both the eyes and glasses have moved up 20 units and Executer waits for additional input. The application continues to accept mouse and keyboard commands, just as it would without speech. ",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Example",
"sec_num": "5"
},
{
"text": "In practice, building a JAvox-based, speech interface -for limited-functionality applications -is straightforward and reasonably quick. To date, we have used three diverse applications as our test platforms. Speech-enabling the last of these, an image manipulation program, took little more than one person-day. Though these applications have been small; we are beginning to explore JAvOX's scalability to larger applications. We are also developing a library of JAVOX grammars for use with the standard Java classes. This resource will shorten development times even more; especially compared to building a SLS from the ground up. One of the existing challenges is to work with applications consisting entirely of dynamic objects, those that cannot be identified at load time. Some typical dynamic-object applications are drawing programs or presentation software; in both cases, the user creates the interesting objects during runtime. We have implemented a system in JSL which allows objects to be filtered based on an attribute, such as color in the utterance: Move the blue square.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D i s c u s s i o n and Future Work",
"sec_num": "6"
},
{
"text": "In situations where there is a one-to-one correlation between a lexical item in the grammar and an object in the program, it is often the case that the lexical item is very similar to the element's identifier. It is quite often the same word or a direct synonym. Since JAVOX is primarily performing upcalls based on existing functions within the program, it also can be predicted what type of objects will cooccur in utterances. In the Mr. cation, we can assume that objects representing a Point or integers will occur when the user speaks of moving a BodyPart. We are developing a system to exploit these characteristics to automatically generate JAVOX grammars from an application's compiled code. The automatically-generated grammars are intended to serve as a starting point for developers -though they may certainly require some hand crafting. Our current, grammar-generation tool assumes the program is written with Java's standard naming conventions. It is imaginable that additional data sources -such as a sample corpus -will allow us to more accurately generate grammars for an application. Though in its infancy, we believe this approach holds vast potential for SLS development.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D i s c u s s i o n and Future Work",
"sec_num": "6"
},
{
"text": "JAVOX provides a fast and flexible method to add a speech-interface to existing Java applications. The application program requires no source-code modification: The JAVOX infrastructure provides all NLP capabilities. We have implemented a grammar and scripting system that is straightforward enough that inexperienced developers and those unfamiliar with NLP can learn it quickly. We have demonstrated the technology on several programs and are commencing work on more ambitious applications. The current implementation of JAVOX is available for download at:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Conclusion",
"sec_num": "7"
}
],
"back_matter": [
{
"text": "This work has been partially supported by the Defense Advanced Research Projects Agency under contract F30602-99-C-0060.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Acknowledgments",
"sec_num": null
}
],
"bib_entries": {
"BIBREF0": {
"ref_id": "b0",
"title": "Automatic program transformation with JOIE",
"authors": [
{
"first": "Geoff",
"middle": [
"A"
],
"last": "Cohen",
"suffix": ""
},
{
"first": "Jeffrey",
"middle": [
"S"
],
"last": "Chase",
"suffix": ""
},
{
"first": "David",
"middle": [
"L"
],
"last": "Kaminsky",
"suffix": ""
}
],
"year": 1998,
"venue": "USENIX Annual Technical Conference (N098)",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Geoff A. Cohen, Jeffrey S. Chase, and David L. Kaminsky. 1998. Automatic program transforma- tion with JOIE. In USENIX Annual Technical Conference (N098), New Orleans, LA.",
"links": null
},
"BIBREF1": {
"ref_id": "b1",
"title": "A New Technique for Parsing Ill-formed Spoken Natural-language Dialog",
"authors": [
{
"first": "D",
"middle": [],
"last": "",
"suffix": ""
},
{
"first": "Richard",
"middle": [],
"last": "Hipp",
"suffix": ""
}
],
"year": 1992,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "D. Richard Hipp. 1992. A New Technique for Pars- ing Ill-formed Spoken Natural-language Dialog. Ph.D. thesis, Duke University.",
"links": null
},
"BIBREF2": {
"ref_id": "b2",
"title": "Automatic dialogue generator creates user defined applications",
"authors": [
{
"first": "Andrew",
"middle": [],
"last": "Pargellis",
"suffix": ""
},
{
"first": "Jeffkuo",
"middle": [],
"last": "",
"suffix": ""
},
{
"first": "Chin-Hui",
"middle": [],
"last": "Lee",
"suffix": ""
}
],
"year": 1999,
"venue": "6th European Conference on Speech Communication and Technology",
"volume": "3",
"issue": "",
"pages": "1175--1178",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Andrew Pargellis, JeffKuo, and Chin-Hui Lee. 1999. Automatic dialogue generator creates user de- fined applications. In 6th European Conference on Speech Communication and Technology, volume 3, pages 1175--1178, Budapest, Hungary.",
"links": null
},
"BIBREF3": {
"ref_id": "b3",
"title": "Natural language access to software applications",
"authors": [
{
"first": "Paul",
"middle": [],
"last": "Schmidt",
"suffix": ""
},
{
"first": "Sibylle",
"middle": [],
"last": "Rieder",
"suffix": ""
},
{
"first": "Axel",
"middle": [],
"last": "Theofilidis",
"suffix": ""
},
{
"first": "Marius",
"middle": [],
"last": "Groenendijk",
"suffix": ""
},
{
"first": "Peter",
"middle": [],
"last": "Phelan",
"suffix": ""
},
{
"first": "Henrik",
"middle": [],
"last": "Schulz",
"suffix": ""
},
{
"first": "Thierry",
"middle": [],
"last": "Declerck",
"suffix": ""
},
{
"first": "Andrew",
"middle": [],
"last": "Brenenkamp",
"suffix": ""
}
],
"year": 1998,
"venue": "Proceedings of COLING-ACL-98",
"volume": "",
"issue": "",
"pages": "1193--1197",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Paul Schmidt, Sibylle Rieder, Axel Theofilidis, Mar- ius Groenendijk, Peter Phelan, Henrik Schulz, Thierry Declerck, and Andrew Brenenkamp. 1998. Natural language access to software applica- tions. In Proceedings of COLING-ACL-98, pages 1193-1197, Montreal, Quebec.",
"links": null
},
"BIBREF4": {
"ref_id": "b4",
"title": "Java speech API specification 1.0",
"authors": [
{
"first": "",
"middle": [],
"last": "Sun Microsystems",
"suffix": ""
},
{
"first": "",
"middle": [],
"last": "Inc",
"suffix": ""
}
],
"year": 1998,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Sun Microsystems, Inc. 1998. Java speech API spec- ification 1.0.",
"links": null
},
"BIBREF5": {
"ref_id": "b5",
"title": "Building 10,000 spoken-dialogue systems",
"authors": [
{
"first": "Stephen",
"middle": [],
"last": "Sutton",
"suffix": ""
},
{
"first": "David",
"middle": [
"G"
],
"last": "Novick",
"suffix": ""
},
{
"first": "Ronald",
"middle": [
"A"
],
"last": "Cole",
"suffix": ""
},
{
"first": "Pieter",
"middle": [],
"last": "Vermeulen",
"suffix": ""
},
{
"first": "Jacques",
"middle": [],
"last": "De Villiers",
"suffix": ""
},
{
"first": "Johan",
"middle": [],
"last": "Schalkwyk",
"suffix": ""
},
{
"first": "Mark",
"middle": [],
"last": "Fanty",
"suffix": ""
}
],
"year": 1996,
"venue": "Proceedings of the International Conference on Spoken Language Processing (ICSLP)",
"volume": "",
"issue": "",
"pages": "709--712",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Stephen Sutton, David G. Novick, Ronald A. Cole, Pieter Vermeulen, Jacques de Villiers, Johan Schalkwyk, and Mark Fanty. 1996. Building 10,000 spoken-dialogue systems. In Proceedings of the International Conference on Spoken Language Processing (ICSLP), pages 709--712, Philadel- phia, PA.",
"links": null
}
},
"ref_entries": {
"FIGREF1": {
"uris": null,
"text": "Schematic of the JAVOX architecture.",
"num": null,
"type_str": "figure"
},
"FIGREF2": {
"uris": null,
"text": "A JAVOX grammar fragment for the Mr. Potato Head domain.",
"num": null,
"type_str": "figure"
},
"FIGREF3": {
"uris": null,
"text": "The JAVOX translation process -NL to JSL -for Move the cap up.",
"num": null,
"type_str": "figure"
},
"FIGREF4": {
"uris": null,
"text": "public <modPOS> = move <PARTS> <DIR> : {: dim Slier; foreach $iter (<PARTS>) $iter.move(<DIR:X>,<DIR:Y>); :}; public <PARTS> = [<ART>] <PART> : {: [<PART>] :}; public <PARTS> = <PARTS> [<CONJ>] [<ART>] <PART> : {:public <DIR> = up : X {: 0 :} : Y {: -20 :}; The translation process for the utterance Move the eyes and g/asses up.",
"num": null,
"type_str": "figure"
},
"FIGREF5": {
"uris": null,
"text": "Potato Head applio f-/,pp f~A-d o-, ......................................................... A simplified class diagram for the Mr. Potato Head application.",
"num": null,
"type_str": "figure"
}
}
}
} |