IVR Engine -- a new core component of our CallStream IVR Platform

Sun Systems Co. Ltd., Bangkok, Thailand

Established in 1993, Sun Systems has succeeded in its mission to offer an open, standards-based voice-data multimedia platform with strong competitive advantages for wireless and wire-line operators. With over 10,000 ports deployed, Sun Systems now has the largest market share for Value-Added Services providers among mobile operators in Thailand. Sun Systems customers include traditional carriers, non-traditional service providers, large private enhanced services providers, enterprises, original equipment manufacturers, value-added resellers and systems integrators.

The mobile provider's customers now make full use of our interactive voice response (IVR) platform for VAS system, handling more than 500,000 calls per day. The system can also be customized very easily, which is important in helping the operator gain an advantage in the extremely competitive mobile marketplace in Thailand.

	The simplified overview of CallStream IVR Platform.
	Click image to enlarge

Using our IVR platform customers can order or change ring-back tones, top-up, find out their current balance, or provision other services. Top-up and balance inquiry are the most often used IVR services. In addition, the system can be used for inbound calls, or for outbound marketing if the operator wants to offer a special deal, or announce a new service.

IVR Engine, one of the core components of our IVR platform, is used to service calls from circuit or packet switched telephone networks controlled by call flow scenarios from user-provided scripts or sent by CallFlow Server via an extensible protocol. It fully supports all types of operator or enterprise equipment and protocols without the need for complex converters via a common extensible driver interface with signalling hardware such as Dialogic (ISDN, Analog or CG and TX series SS7 boards) and TelcoBridges (SS7 boards) for circuit switched or Dialogic HMP board for packet switched telephone networks. It also performs real-time call logging, call statistic collection, and alarms to guarantee Service Level Agreements. In addition to conventional IVR functions, IVR Engine can perform faxing, speech recognition, text to speech or video playback functions. IVR Engine was designed with a modular architecture from the ground up and all its parts, driver interfaces and new additional call flow functions can be easily extended/added.

	TelcoBridges SS7 call control manager: shows the current calls stats during IVR load/stress testing.
	Click image to enlarge

The first production version was deployed in November, 2012 (30 ports) at Thai Airways - Thailand's national flag carrier, introducing speech recognition in addition to conventional IVR functions. A month later it was deployed (120 ports) at TrueMove H - Thailand's third largest mobile operator. It is also scheduled for deployment (960 ports) at AIS - another leading wireless provider, between January - February, 2013.

Lisp is used to implement a SLEE-like (Service Logic Execution Environment) core that integrates different services and resources (implemented as pluggable modules) communicating via a common protocol into one complete working system to service phone calls controlled by user-provided call flow scenarios.

At start up the SLEE-core loads all required and optional modules configured by a user via a configuration file. A service/resource can be later reloaded at any time without stopping other independent services allowing hot-patching; which is very crucial in such applications. Once all modules are loaded the core first starts up a main supervisor that in turn starts and then controls all dependent services and the main SLEE-event loop.

	TelcoBridges SS7 call control monitor: shows the current calls status during IVR load/stress testing.
	Click image to enlarge

Some resources that interface with hardware use Lisp's FFI that talks to a thin wrapper written in C to export the driver's interface. All services and resources use a common object-oriented interface that allows adding to or extending an existing service or resource very easily.

This application first started as a proof-of-concept prototype, in a search for more powerful and better tools to develop complex systems, that was finished just within two months. Thanks to Common Lisp, the resulting working application prototype performed so well, that it took just another month to finish it as a production-ready application with just minor adjustments (mostly bug fixes and minor optimizations).

Common Lisp is a multi-paradigm programming language that does not force a developer the only one-true-way to do things, so the developer can concentrate on actually solving a problems, instead of fighting the language.

Our application fully utilizes the following Common Lisp features not found (or very limited) in other general purpose programming languages, that simplify development of complex systems:

1. Macros - used to describe an interface of resources, services and drivers in a declarative and descriptive ways that simplify reading and more importantly maintenance. Especially useful to describe driver interface and its protocol that hides a lot of boiler-plate code (data structures passed between C and Lisp worlds);
2. Condition System and Restarts - used to handle all events from resources and services via an implemented extensible signalling protocol - a very useful feature in this application domain;
3. CLOS - all services and resources are implemented using object-oriented programming techniques that allow to extend any service or resource module or add a new one based on an already existing implementation. Specifically useful :BEFORE, :AFTER and :AROUND methods that allow you to add minor adjustments to a module's behaviour;
4. Dynamic Variables - used to pass different execution contexts between service and resource modules, simplifies interface design and maintenance;
5. Function/CLOS-method runtime redefinition -- useful in testing and production stages when fixing bugs doesn't require restarting an application in most situations.

LispWorks is a high-quality Common Lisp implementation proven in our application and the reasons we chose it are as follows:

1. Good optimizing compiler: When we started developing a prototype, it performed very well with default optimization settings. The production version has just a few declarations to help the compiler to produce more efficient code;
2. Very stable runtime: Interfacing with external world via FFI and running many threads we never experienced any fatal crashes that would put down a running application;
3. Excellent technical support: When we needed support to run our application on a customer's legacy RHEL4 system the patch was received in just a few hours after request. While testing our delivered application on a customer's machine we wanted to run a profiler and again, a patch arrived in just a few hours;
4. High quality SMP support: LispWorks has one of the best support for SMP compared to other CL implementations. We never had a single problem with running many threads in our application.
5. Easy to use FFI (FLI): Our application interfaces with many types of hardware from different vendors. LispWorks FLI package provides everything we need to write a thin wrapper to a C driver, and it is very easy to use.
6. Good supplied library documentation: Very descriptive and up-to-date information about all LispWorks libraries available in PDF and HTML formats.

The key points above, especially 2, 3 and 4 made us choose LispWorks.

Links:
Our company: Sun Systems
Our customers: Thai Airways  TrueMove H  AIS

Previous Story | Next Story