| { | |
| "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" | |
| } | |
| } | |
| } | |
| } |