Insurance Logic Compiled Directly to C Code

The Customer

Zurich Gruppe Deutschland is part of the globally operating Zurich Insurance Group. It is one of the leading insurers in the property and life insurance business in Germany, offering solutions in insurance, retirement provision, and risk management.

Initial Situation and Challenge

The “Actuarial Practice” team at Zurich develops the actuarial software for the sales systems and portfolio management in the life insurance sector. The main task consists of implementing new life insurance products as well as regulatory and administrative topics.

In doing so, the required functionalities and mathematical procedures are designed in detail on the basis of contract and product data, and then implemented as C code.

Timely delivery of the actuarial software — integrated with the agile way of working — for integration into the surrounding systems is one of the central aspects of the entire product development process.

itemis was commissioned to identify where the software development process could be optimized and to develop a concrete solution to ensure faster delivery of the actuarial software.

Approach and Discovery

We began by observing and analyzing the internal processes. It became clear that time-consuming, manual steps in the technical implementation were slowing down the development of new insurance products.

Zurich’s business analysts defined the functional logic in a Microsoft Word document in the form of pseudocode that was not very homogeneous from a formal perspective. An external service provider was commissioned for the implementation of the functional logic in C code.

The development of the actuarial software — encompassing the stages of conception, implementation, and testing — proceeds through a series of iterations. Test results reveal the need for adjustments in the functional detail specification and in the actuarial functionalities.

External programming took, depending on the scope of the change, a period of several days.

This delay in the delivery of executable code disrupted the development workflow significantly.

Zurich therefore needed a solution for the implementation process that used the legacy code as its basis. Redeveloping the calculation engine was not an option.

The approach to be chosen had to take into account that for a functional release, existing functions usually need to be adapted rather than developed from scratch. This requirement arose from the volume of already integrated products and actuarial logic. Modifications to the software interface are regularly part of the scope of changes.

Solution

Since Microsoft Word was already in use, it made sense to develop an editor that is similarly intuitive to use, but supports business analysts far more effectively in their work.

With the Function Modeling Editor (FuMo Editor), we developed a dedicated tool that understands Zurich’s domain concepts and established “language.”

Given the historically grown legacy, a review of the calculation engine was required. We first manually analyzed and standardized approximately 200,000 lines of legacy code. The goal of this exercise was to translate patterns into simpler concepts of a potential target language.

The challenge was to preserve the given functionality. We were able to meet this requirement through extensive testing based on Zurich’s existing test suite.

The developed domain-specific language (DSL) is oriented toward the familiar Word notation. The tool parses the existing C code and translates it into the “FuMo” language via pattern recognition. We used this functionality to migrate the existing system of function models into the domain-specific language of the FuMo Editor.

During functional further development, after the business analyst has made adjustments, C code is generated again from the FuMo language. The generated code is immediately available and can be tested straight away.

The FuMo Editor is built on the Meta Programming System (MPS). MPS is a language workbench that we have successfully used over recent years to create domain-specific languages for non-programmers.

The great advantage of MPS: there are no restrictions on the notation of data. Data can be defined and visualized in any conceivable form — for example as text, tables, graphics, or with actuarial symbols. This allows business analysts to describe their functions in the familiar language and with the usual notation.

Similar to the development environment (IDE) of a software developer, the FuMo Editor offers the user a wealth of features. These greatly ease the work and prevent errors.

The FuMo Editor …

• detects syntax and semantic errors and reports them to the user.
• recognizes already existing functions, methods, and variables and offers auto-completion.
• navigates to other rules on command.
• provides type safety.
• enables automated refactorings.

A code generator rounds off the editor’s feature set. At the click of a mouse, it generates immediately testable C code from the function described above. The time- and cost-intensive detour via the external service provider has been eliminated.

Customer Benefit

Through the immediate availability of source code following conceptual activities, the development cycle is significantly accelerated.

The direct ability to test makes errors — including functional ones — quickly visible and enables timely improvements. In addition, the generated code exhibits a very high degree of consistency and formality. This is of particular benefit when using the code in debug mode — that is, during development cycles.

Functional error handling has been greatly simplified; IT-specific errors are now fundamentally ruled out.

During the development phase of a release, manual code implementation — which had previously taken up to four weeks — is eliminated. Schedule bottlenecks in the development of the calculation engine have been resolved.