This whitepaper describes how Tail-f Systems delivers on the promise of true model-driven engineering for developing complete modern management systems. It is an approach that enables iterative and agile development without the need for time consuming programming to make a model into a running system. http://www.tail-f.com

1. Tail-f Systems Whitepaper
True Model-driven Development of Management Platforms
Introduction
All engineering organizations strive to develop new products in less time and with fewer resources. If these
goals are to be achieved, productivity improvements must be applied to the development of management
platforms, if for no other reason than the fact that management applications are always on the critical path
for production release.
Traditionally, management applications were developed using protocol-specific frameworks such as those
associated with SNMP. While this approach provided developers with a framework to work within, it was
very limited in scope and only applied to a single management interface. As management applications gained
complexity and multiple interfaces have become the norm, developers are looking for more comprehensive
frameworks.
Model-driven engineering (MDE) is a proven method that holds promise to address this need for faster and
more effective software development. The model-driven engineering approach focuses on creating and
exploiting domain models. It has the potential to increase productivity by maximizing compatibility between
systems, simplifying the process of design, and promoting communication between individuals and teams
working on the system.
However, the challenge with using general tools for model-driven development is that they are seldom able to
transform a model into a running system without significant additional programming. Moreover, the power of
iterative development is lost if domain experts cannot immediately experience changes on a system that
closely resembles the production application.
This whitepaper describes how Tail-f Systems delivers on the promise of true model-driven engineering for
developing complete modern management systems. It is an approach that enables iterative and agile
development without the need for time consuming programming to make a model into a running system.
New Imperatives
Developing modern network management applications is an increasingly challenging process. Management
applications are always on the critical path for release and development timelines are being squeezed to meet
business and competitive goals. In almost every regard, developing management applications has become
more complex. Multiple management interfaces, for example SNMP, CLI, Web UI, and XML are the norm for a
carrier-grade networking device and all management interfaces need to operate consistently and deliver a
positive user experience.
Telecommunications services have become more and more sophisticated and complex use-cases that
underlie the provisioning of services and configuration of network elements must be thoroughly analyzed
and tested. Distributed teams working in different time zones on different modules of the management
platform must coordinate effectively. This is further complicated as EMS/NMS platform developers must
often wait for completion of on-device management software to integrate the two layers of management.
Altogether, the need to find a faster and easier approach to development has never been more critical.
Traditional Approaches Fall Short
Traditionally management applications have been developed in a linear fashion with the stages of definition,
design, coding, and testing as illustrated in Figure 1. This may work for simple applications, but in the real
Tail-f Systems © 2011
Page 1 of 5

2. Tail-f Systems Whitepaper
world it is likely to result in delays due to unforeseen redesign and recoding efforts along with the risk of
releasing dysfunctional software.
Figure 1: Traditional Development Cycle
Protocol-oriented Frameworks
A common approach to building management
frameworks has been centered on solving the issues
for specific protocols and their associated modeling
language, leaving the rest of the application and
other interfaces to be developed manually using
separate APIs. For example, SNMP uses MIBs and
CLIs are based on functional frameworks.
Figure 2 shows that protocol-oriented frameworks
only support the model for the supported protocol
(green boxes). Other functions such as persistence,
transaction management and AAA (red boxes)
plus all other interfaces (red lines) need to be
implemented manually.
A protocol-oriented approach results in silos of management frameworks that need to be separately
Figure 2: Protocol-oriented Frameworks
developed and maintained and creates the following types of challenges:
• How can you keep your domain-experts in the loop?
• If you introduce a new feature on a device, how can you get it represented across all interfaces and
models?
• How can you implement a feature across different southbound interfaces if you are building an
EMS/NMS platform? For example, if you need to configure a MPLS interface both on a CLI device and
another SNMP device, you need to map your MPLS attributes to the underlying MIB objects and CLI
commands.
• Software engineering related issues like mapping different models to databases, managing versions,
and managing transactions across different interfaces.
Modern Software Development Methods
Model-driven development is a well established method for developing software. As illustrated in Figure 3
below, it enables application stakeholders to cooperatively define the model that is rendered into a running
system. The result is a formal specification that is understood by both product planners and developers, and a
running system that fulfills the very same definition. This process can be iterated and refined supporting an
agile development approach where domain-experts are continuously kept in the loop and development time
is significantly reduced.
Tail-f Systems © 2011
Page 2 of 5

3. Tail-f Systems Whitepaper
The concept of model-driven software development makes immense sense for developing modern network
Figure 3: Iterative Model-driven Cycle
management applications. These applications are just too intricate to be designed, coded and validated in a
linear fashion. However, to properly realize the benefits of this approach, a running system must be quickly
derived from changes to the model without the need for time-consuming coding. Moreover, the running
system has to be one that domain specialists can actually view and use. Proper validation of a management
application will require executing multiple operations, using all management interfaces, and observing
impact of configuration changes based on hundreds of use-cases.
As illustrated in Figure 4 below, many model-driven tools are not able to generate a fully functioning
application. Generic modeling tools typically generate C++ and Java classes that map to a model, leaving
developers responsible to build the applications such as AAA, database management, transactions, and more.
In places where there is insufficient detail, models create placeholder routines or stubs. A stub does not
actually do anything other than declare itself and allow the program to compile and be linked with the rest of
the application. In the ideal world, a running system is generated directly from the model and custom code
can be added to enrich/customize the default-generated behavior.
Figure 4: Incomplete Model-driven Frameworks Based on Code-generation
Tail-f Systems’ Approach - Model and Run
The benefits of directly iterating between a model and running system are easy to see and appreciate for any
application. This approach is particularly powerful for management applications. Using the frameworks that
are tied to specific protocols does not achieve this as developers are left with considerable application
programming and the work to build and integrate multiple management interfaces. The logic of using
standard model-based code generators breaks down because the resulting code is incomplete and the
running system cannot be properly validated.
Tail-f Systems © 2011
Page 3 of 5

4. Tail-f Systems Whitepaper
Using Tail-f Systems’ approach to model-driven development, developers can generate a running network
element and management system from a single model without coding or stubs – just model and run.
Customization can then be achieved by enriching the generated system in an iterative manner.
This is possible due to these innovative capabilities:
• Rich Runtime Platform - Most other platforms only address functions close to the protocol while
Tail-f Systems manages a big part of the general features required for a management system
including persistence, transactions, APIs and AAA. Code is largely reusable – saving the cost of
recoding for different projects.
• Rich Rendering Engine – Multiple interfaces are directly rendered from a single model. Tail-f
Systems’ model compiler has numerous back-ends including CLI engines and database schemas.
• Powerful Modeling Language - Tail-f Systems uses YANG (RFC 6020) to model both devices and
services. YANG is a powerful domain-specific language that is used for successful model-driven
architectures. YANG is focused on network management models and not just models in general.
YANG models are flexible and powerful enough to describe service models as well as SNMP and CLI
devices.
• Innovative Mapping Software - Tail-f Systems enables developers to write different model views
and efficiently map these together. Mapping a service model to device models is an example of this.
• No Stubs - Direct generation of a running system without the need for further coding radically
reduces calendar time and allows for iterative development.
• Device Simulator - NCS includes a built-in device simulator that allows developers to code and test
EMS features without access to large network test beds.
Figure 5 below shows a model-driven management architecture that is the result of using Tail-f Systems’
technology.
Figure 5: Tail-f Systems’ Model-driven Architecture
Summary
Tail-f Systems provides a true model-driven development architecture for network management solutions,
both for network elements and the management stations. Developers can use this technology to generate
running systems directly from a model without a single line of code.
Tail-f Systems © 2011
Page 4 of 5

5. Tail-f Systems Whitepaper
The same model generates multiple northbound APIs, database schemas, professional CLIs, and Web UIs.
Management applications can be iterated in an agile manner adding custom behavior to the data model
elements. Tail-f Systems’ approach is in contrast with traditional frameworks which are typically focused on
one protocol and leave a lot of work to the development organization including persistence, security and
developing additional management interfaces.
About Tail-f Systems
Tail-f Systems is the leading provider of configuration management software for networking equipment and
network management systems. Six of the ten largest global networking equipment providers are Tail-f
Systems’ customers.
Users of Tail-f Systems’ products, ConfD and NCS, benefit from bringing their products to market in less time
and with reduced risk while incorporating advanced capabilities and support for industry standards. ConfD is
the leading solution for building on-device management systems for all kinds of networking equipment. NCS
is a powerful automated service provisioning and configuration management application that can be
integrated into an existing EMS/NMS platform or used as a model-driven solution to build new management
systems from scratch. Tail-f Systems is a leading contributor to industry standards organizations including
IETF (NETCONF and YANG), Metro Ethernet Forum, CableLabs, OpenSAF, and TMForum.
Tail-f Systems is headquartered in Stockholm, Sweden. For more information on the company, please visit
www.tail-f.com.
Tail-f Systems © 2011
Page 5 of 5