CA2311965A1 - Application-independent language module for language-independent applications - Google Patents

Application-independent language module for language-independent applications Download PDF

Info

Publication number
CA2311965A1
CA2311965A1 CA002311965A CA2311965A CA2311965A1 CA 2311965 A1 CA2311965 A1 CA 2311965A1 CA 002311965 A CA002311965 A CA 002311965A CA 2311965 A CA2311965 A CA 2311965A CA 2311965 A1 CA2311965 A1 CA 2311965A1
Authority
CA
Canada
Prior art keywords
language
concept
identified
application
expression
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
CA002311965A
Other languages
French (fr)
Inventor
Cleber D. Giorgetti
Marcelo C. Bernardes
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Nokia of America Corp
Original Assignee
Lucent Technologies Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Lucent Technologies Inc filed Critical Lucent Technologies Inc
Publication of CA2311965A1 publication Critical patent/CA2311965A1/en
Abandoned legal-status Critical Current

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/451Execution arrangements for user interfaces
    • G06F9/454Multi-language systems; Localisation; Internationalisation
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00Handling natural language data
    • G06F40/20Natural language analysis
    • G06F40/205Parsing
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00Handling natural language data
    • G06F40/20Natural language analysis
    • G06F40/279Recognition of textual entities
    • G06F40/284Lexical analysis, e.g. tokenisation or collocates
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00Handling natural language data
    • G06F40/20Natural language analysis
    • G06F40/279Recognition of textual entities
    • G06F40/289Phrasal analysis, e.g. finite state techniques or chunking
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00Handling natural language data
    • G06F40/30Semantic analysis
    • G06F40/35Discourse or dialogue representation
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00Handling natural language data
    • G06F40/40Processing or translation of natural language
    • G06F40/55Rule-based translation
    • G06F40/56Natural language generation

Abstract

An application-independent language module for language-independent applications responds to a request from an application identifying a concept that is generic to a plurality of languages and the language that the concept is to be expressed in, by generating and returning an expression of the identified concept in the identified language for the application to communicate. The language module is implemented in object-orientated programming form and includes instances of the following foundation class objects that are provided by an infrastructure for language module development: a concept object for defining the generic concepts in a language-independent manner and pointing to concept definitions each defining the corresponding concept in a different language, a concept definition object for defining the concepts in language-dependent manner and pointing to parsers each for expressing a part of an expression of the concept in the language of the concept definition and associating any variables that are involved in the concept with parsers, and a parser object for expressing parts of the concept expressions and values of any associated variables in the languages of the concept definitions. Variables are defined at the concept level. Also included are foundation classes for languages, variables, and data types.
The development infrastructure further includes an application program interface (API) for creating, modifying, and deleting class instances in a database compilable into the language module repository, and a database of media fragments for forming communicable versions of the concepts.

Description

Bernardes-Giorgetti 1-1 APPLICATION-INDEPENDENT LANGUAGE MODULE FOR
LANGUAGE-INDEPENDENT APPLICATIONS
Technical Field This invention relates to arrangements for automatically s generating messages, such as voice and text announcements, in any of multiple variations, e.g., languages.
Back4round of the Invention Automated message-generating arrangements have a wide range of applications. For example, in interactive voice-response ~ o systems, they are used to generate messages for playback to a user which either provide the user with information or prompt the user for action.
The design and use of the message-generating arrangement is relatively simple if only one language is supported. For example, the sentence structure required for any announcement is known a-priori, thereby making the construction of announcements relatively simple. However, even if only one language is supported, there is still a problem of entering information that is context-dependent or user-dependent into the announcements. An example of context-dependent 2o information is singular versus plural terms. An example of user-dependent information is date information: "day/month" order in some cultures versus "month/day" order in others.
As a result of language-, culture-, or market-specific variations in representing information, the design of the message-2s generating arrangement usually is language-, culture-, or market-specific.
But this limits use of the arrangement to only the particular market, culture, or language for which it was designed, and different designs must be created for each market, culture and language. This is very expensive and highly inefficient.
3o To avoid this problem, efforts have been made to design message-generating arrangements that are language-, culture-, or Bemardes-Giorgetti 1-1 market-independent. For example, U.S. patent no. 5,375,164 discloses a voice-messaging system whose design is based upon "semantic expressions" that are used to evaluate language-, culture-, or market-specific data. While effective, this design still does not separate the s "semantic expressions" from associated application code to the extent needed to make the design completely application-independent and therefore completely versatile and generic.
Summary of the Invention This invention is directed to solving these and other problems and disadvantages of the prior art. Generally according to the invention, there is provided an application-independent language module for language-independent applications. The language module responds to a request identifying a concept that is generic to a plurality of languages and also identifying the language that the concept is to be expressed in by generating and returning an expression of the identified concept in the identified language. All grammar and syntax of the concept in the identified language is defined by the language module. The language module thus separates and hides all language dependencies from applications, while preferably the language module is application-2o independent. The term "language" is used broadly throughout to include culture and market as well as other contexts that affect the expression of concepts.
According to one aspect of the invention, a communications method comprises the following steps. The language module receives 25 identification of a concept that is generic to a plurality of languages, and of a language that the concept is to be expressed in, from an application that needs to communicate the identified concept in the identified language.
In response, the language module generates an expression of the identified concept in the identified language from stored information, and so provides the generated expression to the application for communicating the expression. The application is consequently independent of Bemardes-Giorgetti 1-1 languages including the identified language, and may be used to express the concept in any language for which the language module has the stored information. Preferably, the language module is also independent of applications including this application, and may be used with any s application that can identify to the language module a concept and a language for which the language module has the stored information.
Illustratively, the provided expression identifies stored media fragments and their order that form a communicable version of the concept, and the application obtains the identified media fragments from a database of ~o stored media fragments and communicates them in the identified order.
The language module is thus made media-independent and can be used to generate expressions of concepts in any media (e.g., voice, text, etc.) According to another aspect of the invention, the language module comprises a plurality of stored concept definitions each defining a ~s concept that is generic to a plurality of languages in a language-dependent manner and pointing to parsers each for expressing a portion of an expression of the concept in the language of the concept definition, and further associating any variables that are involved in the concept with the parsers. The language module also comprises a plurality of the stored 2o parsers for expressing portions of the expressions of the concepts in the languages of the corresponding concept definitions and for expressing values of any variables associated with the parsers in the languages of the corresponding concept definitions. The language module further includes a means (a program interface, for example) for receiving 2s identifications of any one of the concepts and of a language that the concept is to be expressed in, and values of any variables involved in the concept, and in response for returning an expression of the identified concept in the identified language. A further means (a processing engine, for example) of the language module responds to the received so identifications by accessing a stored concept definition that corresponds to the received identifications, responds to the accessed concept Bemardes-Giorgetti 1-1 4 definition by using the parsers pointed to by the accessed concept definition to express the portions of the expression in the identified language, including expressing any values of any said variables in the identified language by using any said parsers associated with any said s variables. Illustratively, the language module is implemented in object-oriented programming form where the above-characterized stored entities are object instances of foundation classes (prototype objects) that are also included in the language module.
The language module further preferably comprises a plurality of stored concept objects each representing a different one of the concepts in a language-independent manner and pointing to the concept definitions that define the corresponding concept in language-dependent manners. The processing engine responds to the received concept and language identifications by accessing a concept object that corresponds i s to the identified concept and determining therefrom the concept definition that corresponds to the identified concept and language.
According to yet another aspect of the invention, a communications method involving an application that uses the language module comprises the following steps. The application identifies to the 20 language module a concept that is generic to a plurality of languages and a language that the concept is to be expressed in, in response to needing to communicate the identified concept in the identified language. In response, the application receives from the language module an expression of the identified concept in the identified language, and in 2s response the application communicates the received expression of the concept. The application is thus independent of languages, including the identified language. Illustratively, the received expression identifies media fragments and their order that form a communicable version of the concept, and the application obtains the identified media fragments from a so database of media fragments and communicates those media fragments in the identified order.

Bemardes-Giorgetti 1-1 s The invention encompasses both methods that comprise the above-characterized steps and apparatuses that include the above-characterized elements or effect the method steps. The latter apparatus preferably includes an effector-any entity that effects the corresponding s step, unlike a means-for each step. Further, the invention encompasses computer-readable media containing instructions which, when executed in a computer, either cause the computer to perform the method or cause the computer to embody the apparatus.
These and other features and advantages of the invention ~o will become more apparent from the following description of an illustrative embodiment of the invention considered together with the drawing.
Brief Description of the Drawin4 FIG. 1 is a block diagram of a message-generation ~ 5 arrangement that includes an illustrative embodiment of the invention;
FIG. 2 is a functional diagram of two illustrative prior-art applications that implement the same functionality in two different languages;
FIG. 3 is a functional diagram of a single illustrative 2o application constructed according to the invention that implements the functionality of the two applications of FIG. 2;
FIG. 4 is a functional flow diagram of interactions between the application of FIG. 3 and the language module of the arrangement of FIG. 1;
2s FIG. 5 is a block diagram of the language module of the arrangement of FIG. 1;
FIG. 6 is a functional flow diagram of the process of developing language data contents of the language module of the arrangement of FIG. 1;

Bemardes-Giorgetti 1-1 FIGS. 7A-C are a functional flow diagram of a language developer's illustrative portion of the language module development process of FIG. 6; and FIGS. 8A-B are a functional flow diagram of an illustrative s parse method of the runtime API of the arrangement of FIG. 1.
Detailed Description FIG. 1 shows a message-generation arrangement that includes an illustrative embodiment of the invention. The arrangement ~o includes a server 100 that provides services to users through their communications terminals 101-102, such as telephones 101 and data terminals or personal computers 102. Terminals 101-102 are connected to server 100 via a communications network 103, such as a local area network (LAN), the Internet, or a public or a private telephone network.
15 Server 100 is a stored program-controlled device. It comprises hardware 110, including a processor for executing programs and a memory for storing the programs, an operating system 111 that controls the operation of server 100, platform software 112 that provides basic, generic, services to users and to application software, and application 2o software 114 which implements the high-level services provided by server 100 to users. Users' terminals 101-102 interact with server 100 through a user interface 115, such as a telephony user interface (TUI) comprising telephone line and trunk port circuits and associated signaling, or a graphical user interface (GUI).
2s As described so far, server 100 is conventional. For example, elements 110-112 and 115 together comprise the Lucent Technologies Inc. Conversant~ voice information system, and elements 110-112 and 114-115 together comprise the Lucent Technologies Inc. IntuityT"" messaging system.
so Additionally, server 100 comprises a run-time application program interface (API) 113, a run-time language module 116, and a Bemardes-Giorgetti 1-1 speech database (DB) 117. Alternatively, database 117 may define another medium, e.g., text, or a plurality of media. Run-time API 113 interfaces application software 114 to run-time language module 116.
Application software 114 is also interfaced to speech database 117 by the s platform software 112. Elements 116 and 117 can be located at any level of the software hierarchy (i.e., at the level of any of elements 111, 112, and 114). During normal operation, when application software 114 determines the concept (any information, including any prompt for user input) that it needs to communicate to a user, it requests run-time language module 116 via run-time API 113 to provide the precise expression of the concept that will properly convey that information. After run-time language module 116 specifies the expression, application software 114 accesses speech DB 117 via platform software 112 and retrieves therefrom the speech, text, or other media fragments specified is by module 116 that are needed to compose a communicable version of the concept's expression and causes the expression to be sent to the user. Elements 113 and 116-117 are described in more detail further below.
The message-generation arrangement of FIG. 1 further 2o includes a development platform 150 which is used to develop run-time language module 116 and speech DB 117 of server 100. Development platform 150 is a stored program-controlled device. It comprises hardware 160, including a processor for executing programs and a memory for storing the programs, an operating system 161 that controls 2s the operation of platform 150, and a graphical user interface (GUI) 165 through which a developer's terminal or computer 155 interacts with plattorm 150. As described so far, platform 150 is conventional.
Illustratively, hardware 160 comprises a personal computer (PC) or a workstation, and operating system 161 and GUI 165 together comprise a 3o Windows-type operating system.

Bemardes-Giorgetti 1-1 Additionally, platform 150 includes a development API 170, database administration 171, a language DB 172, speech tools 173, and compiler 174. Database administration 171 is a conventional database manager that is a function of which databases (e.g., Oracle, Informix, etc.) are selected for databases 117 and 172. Speech tools 173 are conventional tools that are conventionally used to develop a speech DB of speech fragments from which voice messages are composed at run-time.
If the messages are desired to be in a medium other than voice, e.g., text, graphics, video, or multi-media, speech tools 173 change accordingly so as to facilitate the development of a database of fragments of the desired medium or media. A developer interfaces with speech tools 173 via GUI 165 in order to generate the contents of speech DB 117.
Language DB 172 stores all rules needed to construct expressions of concepts in each language and/or for each culture or market that have been defined by language DB 172 developers. Run-time language module 116 is an executable version of language DB 172 compiled by compiler 174. Language DB 172 is composed of a framework, which is a database representation of the structure of languages, and of language data, which are the data that define individual 20 languages. Significantly, the framework is language-, culture-, and market-independent. The framework of language DB 172 thus presents a model of a language in which any language and any culture- or market-dependent variants thereof can be represented.
Turning now to FIG. 2, an application 114a or 114b may be 2s viewed as comprising two major distinct types of information: application logic and culture logic. Application logic is the approach used to provide the desired functionality to end-users (e.g., interact with a caller to a bank to provide the caller with an account balance). It is represented in FIG. 2 by the numbered statements. It includes the implementation of business so rules (the need that the application is filling). It is coded and developed by an application specialist (a programmer). The culture logic is the Bernardes-Giorgetti 1-1 approach used to communicate with end-users (e.g., U.S. English or Mandarin). It is represented in FIG. 2 by the indented statements. It includes user-interface standards (e.g., Graphical User Look Listen and Feel (GULLF)). It is developed by a language specialist (a linguist). Each one of these types of information has its own dynamics for development, reuse, and maintenance. So, although they are inter-dependent, they should not be intra-dependent (i.e., they are components of the same application, but the application logic should not be intertwined or directly interact with the culture logic, and vice versa). How this objective is met is io illustrated in FIG. 3.
To meet this objective, we provide a self-contained language module 116 that contains all language-dependent, culture-dependent and market-dependent logic, designated as 116 a and b in FIG. 3, and no application logic (i.e., the contents of module 116 are language-~s dependent but application-independent) so that application 114 contains only application logic and no culture logic (i.e., application 114 is language-independent but application-dependent), as shown in FIG. 3.
Application 114 provides all context information to the language module 116, and language module 116 provides all language information 2o bask to application 114. A usage example, showing how this is accomplished, is given in FIG. 4. Via runtime API 113, application 114 provides a request 400 to language module 116 identifying a particular concept (4400), the language in which that concept is to be expressed (English), the medium in which the concept is to be expressed (recorded 2s speech), and values of variables ($today_date and $balance_1 ) used by the concept. Concepts are generic to a plurality (illustratively all) languages. Via runtime API 113, language module 116 provides a response 401 that lists a sequence of fragment identifiers in speech database 117 which, when they are retrieved via platform software 112 so from speech database 117 and are voiced in the indicated sequence, Bemardes-Giorgetti 1-1 to result in_ the appropriate announcement being communicated, e.g., "On April 15, 1998, you have three hundred dollars in . . . ".
Shown in FIG. 5, language module 116 comprises a repository 500, foundation classes 501, and an engine 502.
s Repository 500 is a store (e.g., a database) of object instances that contains all language-related information (language resources) for use by one or more applications, and a conventional database manager. All grammar and syntax information for all defined concepts in all defined languages is stored in repository 500. Foundation classes 501 are definitions of prototype objects that can be instantiated to allow the developer of the language module (e.g., a language developer) to describe the language resources. They enable the developer to represent language-dependent information in object-oriented programming form, in a way that facilitates use by different applications, to map external i 5 representations of information into corresponding representations internal to repository 500, and to access the language resources in repository 500.
Engine 502 is either a library or a stand-alone processing program that allows either the developer to manipulate the contents of repository 500 or an application 114 to access the contents of repository 500 through an 2o application programming interface (API) without directly using foundation classes 501. Optionally, language module 116 may further include add-ons 503, such as libraries or stand-alone programs that extend the basic language-module functionality to allow a developer to perform repository and media-related information creation and management. Add-ons 503 25 may implement one or more of the following capabilities. Application simulation, which allows a developer to test the repository prior to its use with an application, and supports language resource development without requiring an actual application to support the resource development.
Media check, which verifies that all media-dependent information so accessed by an application is actually available in the run-time environment. Repository migration, which enables the repository and all Bemardes-Giorgetti 1-1 11 media-related information to be moved between and managed in different development environments and installed in the run-time environment.
Media conversion, which converts media-dependent language resources from a variety of different formats into a format suitable for use in the run-s time environment. Support of hatching, which batches a list of media-dependent information that is to be presented to the user simultaneously.
Media proxy, which allows the application simulation to obtain and use media-dependent information obtained through a network. And support for speech recording (e.g., a sound card), which permits a developer to ~o generate media-dependent language resources, such as speech files.
The following is a brief description of the process through which the repository gets populated with language resources as illustrated in FIG. 6. From a description 600 of what an application 114 needs to accomplish, an application specialist 601 specifies the language-related 15 knowledge 602 comprising language elements (e.g., prompts, announcement) that are required by the application and the languages (e.g., English, Spanish, French, Japanese) that the application will use. A
language specialist 603 defines a language-specific representation 604 of the language elements in each language that will be used by the 2o application. The developer 605 of the language module 116 structures the language-specific information 604 in a language-module (LM) representation 606 that is reusable by (i.e., is generic to) all of the languages used by the application. The language module developer 605 then stores the results in language database 172 (see FIG. 1 ).
2s Language database 172 has an associated manager-database administration 171-which is dependent upon the particular database being used and which performs conventional database management functions (e.g., manages accesses to the language resources). The language resources that populate language 3o database 172 include instances of the following foundation class objects 501:

Bernardes-Giorgetti 1-1 ~2 ~ A language, which posits, or defines the existence of, a language in the repository. It comprises a language ID and a language name, both of which are preferably defined consistently with ISO 639/IS0 3166.
~ A concept, which posits, or defines the existence of, a concept in a language-independent manner. It comprises a concept ID, a concept description which is a text description of the purpose of the concept, a concept scope that defines who has access rights to this concept (e.g., application developers, language developers, or both), and a concept variable list that lists the variables that are used as input and output parameters by this concept and the order in which the variables must be presented to this concept. Via the concept ID, it identifies or points to all language-specific definitions of the posited concept.
~ A concept definition, which defines how to implement a specific concept in a specific language; it ties a language and a concept together. It comprises a concept definition component list which lists the language components (e.g., words, phrases) that are used to implement the concept and their order, and a concept definition-to-component-variable mapping that maps the language components to the corresponding variables in the corresponding concept variable list.
2o Not every language component needs to correspond to a variable; a variable can correspond to only one language component. The language components are expressed by parsers, and the concept definition component list points to the specific parsers that implement the expression of the corresponding concept in the corresponding 2s language.
~ A parser, which defines how to convert input data (a portion, e.g., a phrase; of the concept expression, including the value of any input variable) to language fragments of a specific language (and vice versa). A parser may (but may not) accept an input, and generates a 3o syntactically and semantically correct output in the target language and data type that it represents. As in other computer science contexts, a Bemardes-Giorgetti 1-1 13 parser here is an entity that determines the syntactic structure of a language unit by decomposing it into more elementary sub-units and establishing the relationships among the sub-units. For example, to decompose blocks into statements, statements into expressions, and expressions into operators and operands. In this illustrative example, the output takes the form of a sequence of one or more fragment identifiers of fragments in speech database 117. A parser can also be viewed as a dynamic-concept definition.
~ A data type, which defines a type of data (e.g., integer, character, io undefined, etc.) in the same manner as is common in computer programming languages.
~ A variable, which defines a variable ID and its data type, in the same manner as is common in computer programming languages.
In language database 172, languages are constructed from concept definitions. Individual concept definitions may in tum be constructed from other, simpler, concepts. Concepts are in tum constructed from concept definitions, data types, and variables.
In its simplest form, an object is a unit of information. In an object-oriented programming environment, an object contains both 2o attributes and method describing how the content is to be interpreted and/or operated on.
Foundation class objects 501 provide the framework to development API 170 for creating the language resources and populating language database 172 therewith. With respect to each foundation class, 2s the API 170 provides functions to create, modify, or remove (delete) instances of the foundation class object. The create functions check if the identified instance already exists, and if so, deny permission to create it.
The modify functions and the remove functions guarantee referential integrity between the candidate for modification or removal, respectively, so and any other entities that refer to it. If other entities do refer to it, the Bemardes-Giorgetti 1-1 14 developer is forced to modify or remove them before modifying or removing the candidate.
The development API 170 includes the following basic functions.
Development API 170 Function Definition engine id.add Language (Language) Makes a new language known to the database manager and thus available to users. It checks if the language already exists.
engine_id.modifyLanguage Changes an existing language.
~5 (Language, newlnformation) It checks if the new language's information is valid/consistent.
engine id.removeLanguage Removes an existing language.
20 (Language) It checks the impact this removal will have on the language module's referential integrity, and requests actions to guarantee its referential integrity.
Language (language-ID, Creates a wrapper (a data language-name) structure) for a new language with an ID and a so descriptive language name.
Language-ID may include a Bemardes-Giorgetti 1-1 15 language version or other relevant information.
engine_id.addConcept (Concept) Makes a new concept known to the database manager and thus available to users. It checks if the concept already exists.
~o engine_id.modifyConcept Changes an existing concept. It (Concept, newlnformation) checks if the new concept's information is valid/consistent.
engine id.removeConcept(Concept) Removes an existing concept. It checks the impact that this removal will have on the language module's referential 2o integrity, and requests actions to guarantee its referential integrity.
Concept (concept-ID, Creates a wrapper for a new concept-scope, concept with an ID for the new concept-description) concept, indication of the scope of access to this concept, and a so natural-language description of the concept.

Bemardes-Giorgetti 1-1 16 concept id.isDefined Verifies if this concept has (language) already been defined for this language and returns a value indicative thereof.
concept id.addVariable Inserts a new variable (Variable) into the existing concept. This variable can then be associated with parsers. The order of variables in which they are added to the concept defines the order in which their values must be input.
concept id.modifyVariable Changes an existing concept's 20 (Variable, new Information) variable. It checks if the new variable's information is valid/consistent.
2s concept id.removeVariable(Variable) Removes an existing concept's variable. It checks the impact that this removal will have on the language module's referential integrity, and requests actions to so guarantee its referential integrity.

Bemardes-Giorgetti 1-1 Variable(variableld, variableType) Creates a wrapper for a new variable with an ID for the new variable and a data type of this variable. This variable can then be added to existing concepts.
concept id.addConceptDefinition Adds a new concept definition (Concept Definition) to an existing concept. If this concept definition contains a parser, it can be associated with one of this concept's variables.
concept id.modifyConceptDefinition Changes an existing concept's (ConceptDefinition, newlnformation) concept definition. It checks if the new concept definition's information is valid/consistent.
concept id.removeConceptDefinition Removes an existing concept's (ConceptDefinition) concept definition. It checks the impact that this removal will have on the language module's referential integrity, and requests actions to guarantee its referential integrity.
conceptDefinition(Concept, Creates a wrapper for a new j CA 02311965 2000-06-19 Bemardes-Giorgetti 1-1 18 Language) concept definition for the given concept and language. This concept definition is then added to the corresponding concept.
conceptDefinition_id.add Adds a new concept to a ConceptElement(Concept) concept definition. This concept is then part of the concept definition. The order of the elements (concepts & parsers) defines their output order.
~5 conceptDefinition_id.addParser Adds a new parser to (Parser) to an existing concept definition.
This parser can then be associated with variables.
conceptDefinition_id.modifyParser Changes an existing parser. It (Parser, newlnformation) checks if the new parser's information is valid/consistent.
conceptDefinition_id.removeParser Removes an existing parser. It (Parser) checks the impact that this 3o removal will have on the language module's referential Bemardes-Giorgetti 1-1 ~9 integrity, and requests actions to guarantee its referential integrity.
conceptDefinition id. associate Parser Associates an existing variable Variable (Parser-ID, Variable-ID) with an existing parser. This variable's value will henceforth be parsed using this parser.
Parser (parserld) Creates a wrapper for a new parser with an ID for the new parser.
engine_id.getParser(parserlD) Retrieves an existing parser from the repository.
2o engine id.addDataType(DataType) Adds a new data type. This data type can then be associated with variables.
engine_id.modifyDataType Changes an existing data type.
(DataType, newlnformation) It checks if the new data type's information is valid/consistent.
so engine id.removeDataType Removes an existing data type.

Bemardes-Giorgetti 1-1 20 (DataType) It checks the impact that this removal will have on the language module's referential integrity, and requests actions to guarantee its referential integrity.
DataType(dataTypeID) Creates a wrapper for a new data type with an ID for the new data i o type.
FIG. 7 illustrates the use of the development API 170 to create in language database 172 the language resources needed for the ~ s announcement "On (today's date) you have (balance) in your savings account" in U.S. English.
Once the developer has created language DB 172 for a particular language, the developer causes compiler 174 to compile language DB 172 into executable code, which populates repository 500 of 2o runtime language module 116 (see FIG. 5). For example, if language DB 172 is an object-orientated database, the compilation is as simple as a direct data dump (copy) of language DB 172 into repository 500 of module 116.
Once runtime language module 116 has been created, it is 25 available for use by application software 114. Interaction between the two is via runtime API 113, which is supported by engine 502 and includes the following basic functions.
Function Runtime API 113 Definition 3o manager id.getLanguages() Returns all available languages for this manager instance Bemardes-Giorgetti 1-1 21 manager id.getConcepts(Language) Returns all available concepts for this manager instance manager id.getMedia() Returns all available media for this manager instance.
~o manager_id.parse(Language, Returns a list of fragments of Concept, Medium, VariablesValuesList) the given medium that represent an expression of the given concept in the given language. If ~ s the concept has variables, these variables' values are provided in the order specified in the concept. The parse accomplishes this by passing the 2o variables values list to the method parse of the concept definition instance corresponding to the specified language. The result is then converted to the 25 specified medium.
The first three functions (method calls) apply only to manager instances, and involve communication from application 114 to 3o the manager and back again. The fourth function, representing the parse method, involves at the highest level communication from application 114 Bemardes-Giorgetti 1-1 22 to the manager, from the manager to the indicated concept definition, from the concept definition to a parser, from the parser back to the concept definition and therefrom to the manager, and finally from the manager back to application 114. An example of the parse method s implementing the usage example of FIG. 4 is shown in FIGS. 8A-B.
Of course, various changes and modifications to the illustrative embodiment described above will be apparent to those skilled in the art. For example, definitions, naming of functions, and passing of parameters in the APIs may be changed as necessary to adapt to a particular programming environment. The media may change as desired, and the information passed back by the language module may change accordingly: for example, it can pass back text directly instead of fragment pointers. Also, the database structure may be changed; for example, to add legacy information for backwards compatibility. Such changes and ~5 modifications can be made without departing from the spirit and the scope of the invention and without diminishing its attendant advantages. It is therefore intended that such changes and modifications be covered by the following claims except insofar as limited by the prior art.

Claims (27)

1. A communications method comprising:
receiving an identification of a concept that is generic to a plurality of languages and of a language that the concept is to be expressed in from an application needing to communicate the identified concept in the identified language;
in response, a language module generating an expression of the identified concept in the identified language from stored information including a language-specific concept definition of the identified concept for the identified language; and providing the generated expression to the application for communicating the expression.
2. The method of claim 1 wherein:
the application is independent of languages including the identified language; and the language module is independent of applications including said application.
3. The method of claim 1 wherein:
the provided expression identifies stored media fragments and their order that form a communicable version of the concept.
4. The method of claim 3 further comprising:
the application obtaining the media fragments from a database of stored media fragments; and the application communicating the obtained media fragments in the identified order.
5. The method of claim 1 wherein:
the stored information includes definitions of a plurality of concepts, including the identified concept, each for an individual language.
6. The method of claim 1 wherein:
the stored information includes definitions of a plurality of concepts, including the identified concept, for a plurality of languages, including the identified language.
7. The language module of claim 6 wherein:
the stored information includes a plurality of concept objects each representing a different one of the concepts in a language-independent manner and identifying the concept definitions of the represented concept for different languages.
8. The method of claim 1 wherein:
all grammar and syntax of the concept in the identified language is defined by the stored information.
9. The method of claim 1 wherein:
receiving an identification of a concept includes receiving a value of a variable;
generating includes composing an expression of the value of the variable in the identified language; and the communicating includes communicating the expression of the value of the variable.
10. The method of claim 5 wherein:
the definition of the identified concept identifies at least one parser included in the stored information; and the language module uses the identified at least one parser to express the identified concept in the identified language.
11. The method of claim 1 wherein:
the expression of the concept in the identified language comprises a plurality of portions; and the portions are each expressed in the identified language by a corresponding parser included in the stored information.
12. The method of claim 9 wherein:
the variable has a corresponding parser included in the stored information; and the value of the variable is expressed in the identified language by the corresponding parser.
13. A language module that enables applications to communicate concepts in language-independent manner, comprising:
storage means storing a plurality of concept definitions each defining a concept that is generic to a plurality of languages in a language-dependent manner and pointing to parsers each for expressing a portion of an expression of the concept in the language of the concept definition and further associating any variables that are involved in the concept with the parsers, and a plurality of said parsers for expressing portions of the expressions of the concepts in the languages of the corresponding concept definitions and for expressing values of any variables associated with the parsers in the languages of the corresponding concept definitions;
means for receiving identification of any one of the concepts and of a language that the concept is to be expressed in and also receiving values of any variables involved in the concept, and in response returning an expression of the identified concept in the identified language; and means cooperative with the receiving means and the storage means, responsive to the received identifications for accessing a stored concept definition that corresponds to the received identifications, responsive to the accessed concept definition for using the parsers pointed to by the accessed concept definition to express the portions of the expression of the identified concept in the identified language, including expressing any values of any said variables in the identified language by using any said parsers associated with any said variables.
14. The language module of claim 13 wherein:
the stored information includes a plurality of concept objects each representing a different one of the concepts in a language-independent manner and identifying the concept definitions of the represented concept for different languages; and the accessing means respond to the received identification of the concept and the language by accessing the concept object that corresponds to the identified concept and determining therefrom the object definition that corresponds to the identified concept and language.
15. The language module of claim 13 wherein:
all grammar and syntax of each said concept in each said language is .defined by contents of the storage means.
16. The language module of claim 13 wherein:
the storage means stores a plurality of concept objects each defining one of the concepts in a language-independent manner and identifying the concept definitions that define the corresponding concept for different languages.
17. The language module of claim 13 wherein:
the storage means further stores a plurality of variable objects each defining one of the variables as corresponding to a particular data type;

a plurality of data type objects each defining a particular type of data; and at least one language objects each defining an individual language.
18. The language module of claim 13 in combination with a database of media fragments, wherein:
the returned expression identifies the media fragments and their order forming a communicable version of the identified concept in the identified language.
19. A communications method comprising:
an application identifying to a language module a concept that is generic to a plurality of languages and a language that the concept is to be expressed in, in response to needing to communicate the identified concept in the identified language;
in response, the application receiving from the language module an expression of the identified concept in the identified language; and in response, the application communicating the received expression of the concept;
so that the application is independent of languages including the identified language.
20. The method of claim 18 wherein:
the language module is independent of applications including said application.
21. The method of claim 19 wherein:
the received expression identifies media fragments and their order that form a communicable version of the concept; and communicating comprises the application obtaining the media fragments identified by the received expression from a database of media fragments, and the application communicating the obtained media fragments in the identified order.
22. The method of claim 19 wherein:
all grammar and syntax of the concept in the identified language is defined by the language module.
23. The method of claim 19 wherein:
identifying includes the application specifying a value of a variable;
receiving includes receiving an expression of the value of the variable in the identified language; and communicating includes communicating the received expression of the value of the variable.
24. An apparatus for carrying out the method of one of the claims 1-12.
25. A computer-readable medium containing instructions which, when executed in a computer, cause the computer to perform the method of one of the claims 1-12.
26. An apparatus for carrying out the method of one of the claims 19-23.
27. A computer-readable medium containing instructions which, when executed in a computer, cause the computer to perform the method of one of the claims 19-23.
CA002311965A 1999-06-28 2000-06-19 Application-independent language module for language-independent applications Abandoned CA2311965A1 (en)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US09/340,599 US6292773B1 (en) 1999-06-28 1999-06-28 Application-independent language module for language-independent applications
US09/340,599 1999-06-28

Publications (1)

Publication Number Publication Date
CA2311965A1 true CA2311965A1 (en) 2000-12-28

Family

ID=23334106

Family Applications (1)

Application Number Title Priority Date Filing Date
CA002311965A Abandoned CA2311965A1 (en) 1999-06-28 2000-06-19 Application-independent language module for language-independent applications

Country Status (5)

Country Link
US (1) US6292773B1 (en)
EP (1) EP1067465A1 (en)
JP (1) JP2001056814A (en)
BR (1) BR0002784A (en)
CA (1) CA2311965A1 (en)

Families Citing this family (16)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7072330B2 (en) * 1998-04-03 2006-07-04 Consolidated Ip Holdings, Inc. Systems for voice and data communications having TDM and packet buses and telephony station cards including voltage generators
US6498791B2 (en) 1998-04-03 2002-12-24 Vertical Networks, Inc. Systems and methods for multiple mode voice and data communications using intelligently bridged TDM and packet buses and methods for performing telephony and data functions using the same
US6181694B1 (en) 1998-04-03 2001-01-30 Vertical Networks, Inc. Systems and methods for multiple mode voice and data communciations using intelligently bridged TDM and packet buses
US6389009B1 (en) 2000-12-28 2002-05-14 Vertical Networks, Inc. Systems and methods for multiple mode voice and data communications using intelligently bridged TDM and packet buses
US20090059818A1 (en) * 1998-04-03 2009-03-05 Pickett Scott K Systems and methods for providing configurable caller id iformation
US6154465A (en) * 1998-10-06 2000-11-28 Vertical Networks, Inc. Systems and methods for multiple mode voice and data communications using intelligenty bridged TDM and packet buses and methods for performing telephony and data functions using the same
US9037451B2 (en) * 1998-09-25 2015-05-19 Rpx Corporation Systems and methods for multiple mode voice and data communications using intelligently bridged TDM and packet buses and methods for implementing language capabilities using the same
US20020152064A1 (en) * 2001-04-12 2002-10-17 International Business Machines Corporation Method, apparatus, and program for annotating documents to expand terms in a talking browser
WO2002088977A1 (en) * 2001-04-30 2002-11-07 Blue Martini Software, Inc. Methods for creating a multilingual web applications
US7464384B2 (en) * 2002-03-14 2008-12-09 International Business Machines Corporation Method for inter-object communication
FR2841355B1 (en) 2002-06-24 2008-12-19 Airbus France METHOD AND DEVICE FOR PROVIDING A SHORT FORM OF ANY TERM WHICH IS USED IN AN ALARM MESSAGE INTENDED TO BE DISPLAYED ON A SCREEN OF THE AIRCRAFT STEERING UNIT
US7706359B2 (en) * 2002-07-01 2010-04-27 Converged Data Solutions, Inc. Systems and methods for voice and data communications including a network drop and insert interface for an external data routing resource
US7869424B2 (en) * 2002-07-01 2011-01-11 Converged Data Solutions Inc. Systems and methods for voice and data communications including a scalable TDM switch/multiplexer
US7516442B2 (en) * 2003-10-23 2009-04-07 Microsoft Corporation Resource manifest
US9733901B2 (en) 2011-07-26 2017-08-15 International Business Machines Corporation Domain specific language design
US9852123B1 (en) 2016-05-26 2017-12-26 Google Inc. Semiotic class normalization

Family Cites Families (22)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4615002A (en) 1983-03-30 1986-09-30 International Business Machines Corp. Concurrent multi-lingual use in data processing system
US4595980A (en) 1983-07-27 1986-06-17 International Business Machines Corp. Interactive data processing system having concurrent multi-lingual inputs
US5083268A (en) 1986-10-15 1992-01-21 Texas Instruments Incorporated System and method for parsing natural language by unifying lexical features of words
US4887212A (en) 1986-10-29 1989-12-12 International Business Machines Corporation Parser for natural language text
US4949302A (en) 1986-11-17 1990-08-14 International Business Machines Corporation Message file formation for computer programs
US4870610A (en) 1987-08-25 1989-09-26 Bell Communications Research, Inc. Method of operating a computer system to provide customed I/O information including language translation
CA2003418A1 (en) 1988-12-29 1990-06-29 Louis A. Winans Computer message & screen communications in a multi-lingual network
SE466029B (en) 1989-03-06 1991-12-02 Ibm Svenska Ab DEVICE AND PROCEDURE FOR ANALYSIS OF NATURAL LANGUAGES IN A COMPUTER-BASED INFORMATION PROCESSING SYSTEM
US5339421A (en) 1991-03-22 1994-08-16 International Business Machines Corporation General data stream parser for encoding and decoding data and program interface for same
US5339240A (en) 1991-06-28 1994-08-16 Digital Equipment Corporation System and method for construction of language independent print format statements through use of data structures for arbitrary ordering of print parameters
US5428772A (en) 1991-10-01 1995-06-27 Prime Computer, Inc. Data processing system providing user interaction in multiple natural languages
US5375164A (en) 1992-05-26 1994-12-20 At&T Corp. Multiple language capability in an interactive system
US5442782A (en) 1993-08-13 1995-08-15 Peoplesoft, Inc. Providing information from a multilingual database of language-independent and language-dependent items
US5651095A (en) 1993-10-04 1997-07-22 British Telecommunications Public Limited Company Speech synthesis using word parser with knowledge base having dictionary of morphemes with binding properties and combining rules to identify input word class
WO1995027360A1 (en) * 1994-03-31 1995-10-12 Citibank, N.A. Interactive voice response system
US5678039A (en) 1994-09-30 1997-10-14 Borland International, Inc. System and methods for translating software into localized versions
US5640558A (en) 1995-05-31 1997-06-17 International Business Machines Corporation Identifying and analyzing multiple level class relationships in an object oriented system by parsing source code without compilation
US5737617A (en) 1995-06-06 1998-04-07 International Business Machines Corporation Method and system for English text analysis
US5805775A (en) 1996-02-02 1998-09-08 Digital Equipment Corporation Application user interface
US5875422A (en) * 1997-01-31 1999-02-23 At&T Corp. Automatic language translation technique for use in a telecommunications network
US5960382A (en) * 1997-07-07 1999-09-28 Lucent Technologies Inc. Translation of an initially-unknown message
US6058166A (en) * 1997-10-06 2000-05-02 Unisys Corporation Enhanced multi-lingual prompt management in a voice messaging system with support for speech recognition

Also Published As

Publication number Publication date
BR0002784A (en) 2001-01-30
JP2001056814A (en) 2001-02-27
US6292773B1 (en) 2001-09-18
EP1067465A1 (en) 2001-01-10

Similar Documents

Publication Publication Date Title
US6321190B1 (en) Infrastructure for developing application-independent language modules for language-independent applications
US6292773B1 (en) Application-independent language module for language-independent applications
US7197739B2 (en) Apparatus for automatically generating source code
Phanouriou Uiml: a device-independent user interface markup language
US8050907B2 (en) Generating software components from business rules expressed in a natural language
US7487440B2 (en) Reusable voiceXML dialog components, subdialogs and beans
Taha Multistage programming: its theory and applications
AU2005241459B2 (en) Generating programmatic interfaces from natural language expressions of authorizations for request of information
US20080216060A1 (en) System for translating diverse programming languages
US7460996B2 (en) Using strong data types to express speech recognition grammars in software programs
WO2008082771A1 (en) Creating and managing a policy continuum
WO2008054331A1 (en) System and method for processing language independent natural language statements
US6493662B1 (en) Rule-based number parser
WO2005109242A2 (en) Generating programmatic interfaces from natural language expressions of authorizations for provision of information
CN113312113A (en) Dynamic configuration method, device, equipment and storage medium of business rule information
Pianta et al. Mixing representation levels: The hybrid approach to automatic text generation
Kraas On the automation-supported derivation of domain-specific UML profiles considering static semantics
Leitao et al. NLForSpec: Translating Natural Language Descriptions into Formal Test Case Specifications.
Abrams et al. User interface markup language (UIML) specification
CN113568692B (en) Multilingual display method, device, electronic equipment and storage medium
Bui An evolutional domain oriented approach to problem solving based on web service composition
CN114780265A (en) Cross-system service calling method, device and related equipment based on DSL
CN115809086A (en) Three-party library transplanting method, terminal and readable storage medium
Gatius et al. Adapting general linguistic knowledge to applications in order to obtain friendly and efficient NL interfaces
Helms et al. User Interface Markup Language (UIML) Version 4.0

Legal Events

Date Code Title Description
EEER Examination request
FZDE Discontinued