Close examination of any complex speech application quickly reveals that similar dialog patterns, small and large, repeat themselves throughout the application. This suggests a high potential for reusability in application design and implementation. Unfortunately, the fact that almost any dialog must be adapted based on the context in which it occurs has so far made it difficult to achieve a significant level of reusability.

Although different solutions have been proposed in the form of "reusable dialog components" (which typically encapsulate the complete dialog, prompts, and grammars for collecting an information token, e.g., a credit card) the reusability offered by such dialog components has in practice been very limited. For instance, there is usually no way to design dialog components from other components — either through inheritance or composition. Similarly, mechanisms for configuring a dialog are very limited. For instance, the dialog is usually "hard-coded", making it impossible to modify or override certain portions.

Such limitations are readily apparent in today's large applications, which often exhibit an extensive amount of "copy-paste", making application development, testing, and maintenance — as well as dialog design specification — unnecessarily complex.

The Nü Echo Dialog BuilderTM, an Eclipse-based, graphical environment for developing speech applications, was specifically developed in order to address this challenge.

A graphical, pattern-based, dialog design approach

The Nü Echo Dialog Builder^TM completely transforms the process of designing and implementing dialogs by specifically orienting the design process around the identification, definition and reuse of hierarchical dialog patterns. This has been achieved by enabling dialog design to be done through inheritance and composition of dialog patterns. More specifically:

• Dialogs are defined in terms of other dialogs; through inheritance, they automatically inherit the properties and behaviors of the parent dialog.
• A powerful composition and overriding mechanism allows the aggregation of simpler dialogs to form more complex dialogs, while locally overriding properties of the embedded dialogs.
• Any dialog state — often itself a dialog — can be overridden. This provides a very powerful mechanism for adapting a dialog, for instance by changing its confirmation or its list navigation dialog.

This dialog design approach provides several very important benefits. In particular:

• It encourages a dialog design process in which common dialog patterns are identified and factored out so that they can be reused across the application;
• The use of inheritance as a replacement for "copy-paste" results in compact applications that are less bug-prone, easier to test, and easier to maintain;
• Fixing a dialog behavior once fixes it everywhere it is used in the application;
• Inheritance-based dialog specifications makes it easy to see how different dialogs that derive from the same dialog pattern differ from one another (and from the parent dialog);
• By relying in dialog inheritance, it is possible to build complex applications in which any dialog behavior is specified only once. This makes for compact, solid, and easy to maintain applications.

Java runtime

The Nü Echo Dialog Builder^TM produces a dialog specification in DSXML (Dialog Specification XML). This specification is used by the Nü Echo application platform runtime environment in order to execute the dialog. Any required support code — e.g., for implementing business logic, access back-end systems, or implementing complex semantic processing — can be written in Java and called from the dialog through embedded ECMAScript scripting.

All resources (prompts, grammars) are uniquely identified and mapped to physical resources. These mappings can be easily overridden to provide alternate resources to the final application.

A test-driven philosophy

Tests are an integral part of any software development activity and speech applications are no exception. That's why tests are at the heart of the Nü Echo approach to speech application development.

For this reason, the Nü Echo Dialog Builder^TM and its associated runtime are based on a fully introspectable dialog model. This model exposes enough information to let the application developer implement dialog unit tests (using the JUnit test framework) that can be run without having access to a voice browser or even without running the application on a web server. These tests can be integrated directly in the build process, therefore ensuring the integrity of the application each time it is built. The dialog unit testing infrastructure can check the coverage of all unit tests and report which dialog states and transitions (in the entire application) have not been covered. In addition, dialog unit tests can target specific components or modules instead of the whole application, which allows tests to be written in parallel with the dialogs.

Other test-related features include:

• Automated prompt validation — Validate that no prompts are missing in the packaged application. Validation is performed systematically during application packaging and the application release process.
• Interactive HTML testing interface — Using any web browser, the complete application can be interactively tested without the need for a voice browser. This interface can simulate all sorts of events that can occur during the course of a real call (noinput, nomatch, low recognition confidence, hang up, etc.), therefore making it possible to test very specific conditions that would very difficult to test using a telephone.
• Call generator compatible mode — DTMF synchronization sequences can be associated with states in the dialog components, thereby enabling the implementation of load tests or automated functional tests.
• Call generator (Nü Bot) — The Nü Bot intelligent call generator is used to test that the application behaves as expected. A limitless variety of test scripts can be used to test a wide range of test scenarios. These test scripts can be built manually or automatically based on actual call logs.

Main Characteristics

Inheritance-based — The ability to use dialog behavior inheritance is unique in the industry. It maximizes reusability, minimizes "copy-paste", and results in compact applications that are less bug-prone and easier to test and maintain.

Visual editing — Most speech application development tools provide some form of graphical dialog design tool and the Nü Echo Dialog Builder^TM is no exception. However, the Nü Echo Dialog Builder^TM is absolutely unique in that it elevates visual dialog design to a new level by making it easy to visualize and manipulate dialog inheritance and composition.

Mixed-initiative support — Listeners are special dialogs that "listen" to caller interactions in parallel to normal dialogs. They are mainly used for implementing global behaviors (like universal commands) or mixed-initiative dialogs.

Packages — Dialogs can be organized in packages, much like in the Java programming language, to help cope with large sets of DSXML files.

Platform independent — The DSXML dialog specifications produced by the Nü Echo Dialog Builder^TM are independent from any speech platform or operating system and can target VoiceXML, SALT, as well as native IVR platforms.

Fully integrated with the Java programming language — Support code can be written in Java and called from the ECMAScript scripts embedded in the dialog specification.

Logging and reporting — The DSXML runtime platform provides built-in detailed logging and reporting, and is supported by full-featured call analysis and reporting tools.