IVR Deconstructed

Have you ever been on an IVR phone application where you’re asked to enter a string of digits (say, an identification number or social security number) and you had to wait for a couple of seconds before hearing an IVR response? Kinda annoying, right?

Well, you can use the awesome <property>, termmaxdigits, to solve this issue. Let’s take a look at a VoiceXML code example:

<?xml version=”1.0″?>
<vxml version=”2.0″>
<property name=”termmaxdigits” value=”true”/>
<property name=”interdigittimeout” value=”3s”/>
<form>
<field name=”social” type=”digits?length=9″>
<prompt>
Please enter your social security number.
</prompt>
<filled>
<prompt bargein=”false”>
You entered <value expr=”social”/>.
</prompt>
</filled>
<nomatch>
You did not enter a nine digit entry.
<reprompt/>
</nomatch>
<noinput>
You did not enter anything.
<reprompt/>
</noinput>
</field>
</form>
</vxml>

From this IVR example, by setting “termmaxdigits” to true, we can allow for no timeout as soon as the user has matched the maximum number of digits (in this case, 9). If the user enters 9  numbers, the behavior of the application immediately returns a response to the user. If the user entered less than 9 numbers, the application waits for 3 seconds from the “interdigittimeout” property and returns a <nomatch> after 3 seconds has passed with nothing inputted. If the user entered more than 9 numbers, the application returns just the first 9 digits that were entered by the user.

Using this practice in your IVR code will help improve the experience of IVR users as they would be able to proceed faster through your application.

Many times on the forum I’ve seen developers use JSGF grammars in their IVR code when they should be using SRGS+XML and vice versa. Typically, for production IVR code, we use JSGF grammars for small-sized grammars and use SRGS+XML grammars for medium to large-sized grammars.

Why use JSGF for small-sized grammars over SRGS+XML? Because of the sheer verbosity that’s included with using SRGS+XML over JSGF. Let’s take a look at an IVR example.

Let’s say we wanted a VoiceXML grammar that captures a phone keypad entry from 1 to 5.

Here’s the JSGF version of that grammar:

<grammar type=”application/x-jsgf” mode=”dtmf”>
1|2|3|4|5
</grammar>

Pretty simple, huh? Now, let’s take a look at the SRGS+XML version of that grammar:

<grammar type=”application/srgs+xml” root=”ROOT” mode=”dtmf”>
<rule id=”ROOT”>
<one-of>
<item>1</item>
<item>2</item>
<item>3</item>
<item>4</item>
<item>5</item>
</one-of>
</rule>
</grammar>

Wow, that’s a whole lot different. I mean, look at all those VoiceXML tags. And all we want to do is capture a one digit entry from the caller. Thus, for these small grammar situations, we want to use JSGF.

Now, let’s take a look at a more complicated example. Let’s say we want a grammar for pets, where if the caller says “Puppy” or “Dog”, the grammar captures “Dog”. If the user says “Cat”, “Kitten”, and “Kitty”, the grammar captures “Cat”. Lastly, if the user says “Turtle” or “Tortoise”, the grammar captures “Turtle”.

Here’s the JSGF version of that grammar:

<grammar type=”application/x-jsgf” mode=”voice”>
(
((Puppy | Dog) {Dog}) |
((Cat | Kitten | Kitty) {Cat}) |
((Turtle | Tortoise) {Turtle})
)
</grammar>

Here’s the SRGS+XML version of that grammar:

<grammar type=”application/srgs+xml” root=”ROOT” mode=”voice”>
<rule id=”ROOT”>
<one-of>
<item>Dog <tag>pet=’Dog’</tag> </item>
<item>Puppy <tag>pet=’Dog’</tag> </item>
<item>Cat <tag>pet=’Cat’</tag> </item>
<item>Kitten <tag>pet=’Cat’</tag> </item>
<item>Kitty <tag>pet=’Cat’</tag> </item>
<item>Turtle <tag>pet=’Turtle’</tag> </item>
<item>Tortoise <tag>pet=’Turtle’</tag> </item>
</one-of>
</rule>
</grammar>

In this case, although the SRGS+XML version of this grammar looks more wordy in this example, it will perform better than its JSGF counterpart due to less processing/pre-parsing during the startup of the application.

Hope this example helps you developers out there who’ve had questions on when to choose JSGF or SRGS+XML format for your grammar.