Rapid Network Management Application Development

Luca Deri IBM Zurich Research Laboratory, University of Berne

Whereas the recent hardware innovations brought increasingly powerful computers to the market at constantly lower prices, the development cost and time of software applications has not decreased at all. In the field of network management, applications and tools are usually large, expensive and difficult to build and maintain, preventing their diffusion. This paper proposes three ways building low-cost management applications including a new method for rapid application development based on tools developed by the author. Reducing development time, complexity and cost gives developers the chance to create their own management applications without having to be network management experts or highly skilled developers. Keywords: Network Management, Rapid Application Development, Java, Tcl/Tk, World Wide Web.

1. Introduction
Network management application development is usually considered a task for highly specialised developers. This is because developers must have the necessary skills in both network/system management and application development for a certain platform in order to fulfil this task. In case the application being developed has a graphical appearance, the developer should also be familiar with the windowing toolkit present on the target platform. If the application has to be ported on different platforms, aspects such as portability and performance must also be taken into account [Tsichritzis89]. Quite often, network management platforms [IBM_TMN] offer facilities for application development. Developers can take advantage of class libraries or collections of routines which simplify the interaction with the managed resources and which allow them to exploit desired services provided by the management platform. Although this way to develop management applications is widespread, it has some drawbacks: the developed application relies on the management platform, hence it can run if and only if the platform is installed on the client machine (i.e. an application based on IBM NetView cannot run on a host where NetView is not installed); in order to run the application on multiple client machines, it is necessary to purchase a licence of the management platform (not considering the application) for each client machine, hence the application being developed is rather expensive; developers must be familiar with the management platform being used other than having the skills previously identified; although the management platform usually runs on different operating systems, the application quite often has to be modified significantly during the porting phase because the management platform very seldom operates uniformly on different operating systems; facilities offered to develop applications with a graphical appearance, if any, are usually very limited;

there is no (defacto) standard for application development which facilitates the communication and the composition of management applications (for instance large management platforms often come with several applications which cannot communicate at all, not even via basic cut and paste);. The main consequences of this way to develop management applications are: developers need further skills, which increases the development costs; developed applications can run only on those platforms on which the management platform is available; there is no application generic enough to manage a large variety of managed resources (the most generic application is a simple browser); hardly it is not possible to use existing management applications and make them cooperate in order to obtain the needed management functionality. Other than this, management platforms offer nearly no facilities for prototyping applications, nor provide a development environment that would allow the development process to be simplified. From another perspective the process of application development is even more complicated because developers create applications tightly coupled with a specific environment which cannot be run outside it. Additionally, management platforms are rather complex preventing them from being updated frequently and hence from keeping pace with the evolution of the computer world. For instance none of the best-selling management platforms have provided real facilities for developing Internet-aware applications nor they have offered tools for developing applications capable of exploiting a distributed and mobile environment. The aim of this paper is to present a new method for building network management applications in a short amount of time and at low cost without having necessarily to rely on large management platforms. It is worth mentioning that the ability to create applications rapidly and easily has been one of the reasons that turned simple programming languages such as Basic into killer languages usable by the masses. Therefore instead of reinventing tools for application development and adding them to management platforms, the opposite solution is preferred. Some (class) libraries for network management have been developed in order to allow rapid application development (RAD) tools, such as IBM VisualAge or Borland Delphi, to be used for network management application development which can run stand-alone or exploit the services of the corporate management system. The result is that it is now possible to prototype/build management applications in a fraction of the time needed to build the same application using traditional methods. This paper demonstrates that the creation of management applications is no longer a task for very skilled developers but that average programmers can build outstanding applications by exploiting the power of RAD tools which are now mature and widely available on the market for many platforms. 1.

Rapid Application Development and Network Management

In the past few years one of the most frequently used terms in the software engineering field, and even in the network management field [Schmidt95], has become the word visual. This term is often used to identify packages which allow a certain task to be performed efficiently and easily by visually performing a certain activity in an interactive way. Although this term has often been misused, it frequently refers to how rapidly applications can be built using a certain tool. This is because: visual development is interactive and hence faster than classic edit-compile-run application development: it allows one to immediately see the effects of a certain operation immediately

without the need to build and run the application; visual tools are simpler to use and more powerful than traditional tools/languages, so average programmers can build very complex applications in a limited amount of time without having to be software gurus. It is worth mentioning that visual developments has also some drawbacks in terms of flexibility in case the development tools do not provide support for all the facilities a developer needs although they are present in the operating system (for instance balloon help). Visual development is simply an aspect of application development. To build an application visually does not necessary mean that the application can be built in a short amount of time. Moreover, the visual construction process is no guarantee of ease of development. For this reason a new term, RAD, has been invented to identify the tools and systems that allow applications to be built rapidly in a relatively simple fashion. RAD tools are characterised by (most of) the following properties: the overall time needed to build an application is minimised; RAD tools exploit the visual development paradigm (the reverse is not necessarily true); the development environment takes care of many low-level problems such as application linking; RAD tools do not generate code but they rather allow the composition of basic elements in order to build the final application. In the past few years, research and industry have invested much effort in the field of component-based applications and architectures [Joch96] [Nierstrasz92] [Nierstrasz95] [Udell94] [Deri96b]. Software composition appears to be a very promising way to cut development time and to build applications that need to be often modified as the requirements change.

Figure 1: Issues in Software Composition RAD tools provide a rich set of basic components ranging from visual interface to remote application communication. As the component interface usually follows a well-defined guideline [OpenDoc] [OLE], it is possible to use the same component in different contexts and employ components produced by different people. Quite often the component one needs has already been built by someone and put on a public repository. Although RAD is becoming increasingly important in the software industry, the network management world is apparently uninterested in this new technology. This is because: RAD is mainly diffused throughout the PC industry, whereas most of the network management applications run on UNIX boxes; RAD is usually employed to produce applications with a graphical user interface with particular emphasis on database communication and multimedia;

since RAD has to be simple enough to be used by an average programmer, so programming languages used by RAD tools are usually simple and (often) interpreted, hence they are slightly less performant that languages such as C/C++ used in the management world. The increasing use of PCs for everyday business that contributed to the replacement of many UNIX terminals and demonstrated that a graphical interface can quite often substitute the shell interface. The obvious consequence of this trend is that many old-fashioned character-based applications have acquired a graphical interface in order to be used not only by administrators but also by advanced end-users who need to control certain critical resources for their activity. As most of these end-users now have a PC, they need applications that run on their PC with the same look and feel as other applications they use, such as a word-processor or spreadsheet.

Figure 2: Trend in the Computer Industry: from Terminals to PCs Nevertheless business-critical resources are still managed by an administrator, which often uses a character-based application that usually faster and more powerful than an equivalent user interface, especially for repetitive tasks. Owing to this tendency, it is becoming increasingly important to develop and maintain simple yet powerful applications that run on PCs and are a subset of the ones running on the corporate host and are used to manage mission-critical resources. In addition, because many end-users run their applications on portable machines, it is necessary to ensure that management applications do not require large computing capabilities or rely on local network resources, which may become a bottleneck when they are accessed remotely over a slow link. Besides this trend, users of large management platforms realised that quite often they need to develop or customise the applications part of the platform in order to adapt it to their needs. Owing to the high costs of training and maintenance, it is important that end-users can develop/customise the applications they need in a relatively small amount of time and that this task be performed by average programmers and not by highly paid specialists. In conclusion, it is becoming necessary to rapidly and easily develop simple yet powerful management applications that run primarily on PCs, because: average end-users are accustomed to simple graphical user interfaces whilst administrators can still use the shell interface, which is more powerful and faster but more difficult to use; average developers must be able to develop and maintain the application their company needs without being experts of both PC application development and network management; mobile computing demands simple applications that can run from remote locations over slow links.

3. How to Build Management Applications Rapidly

Once the necessity to develop management applications that may rely partially on the corporate

management platform is clear, it is time to decide which platform the application has to run on and how complex the user interface has to be. The following table compares three techniques that can be used to build management applications efficiently. Java, Java Beans, HTML/VRML TCL RAD Tool JMAPI Development/Maintenance Average/Low Average Average Low Time Development Skills Basic Average/High Average Average Application Size Small Large Large Average/Large (Disk/Memory) Platform Yes Yes Yes No Independence Internet-Awareness Yes Yes Low Low/Average High (Java Desktop Integration Average Very Low High Beans) Dynamic Data No Yes Yes Yes Handling Figure 3: Comparison of Techniques for Rapid Application Development In the first case the application is composed of several HTML/VRML pages that allow people to manage network resources using a basic user interface. End-users interact with HTML elements such as buttons and menus, and an HTTP server application interprets the user commands which have been mapped transparently to URLs. The developer is not responsible for the user interface because the Web browser is the environment in which the application runs, hence it is the one that handles the graphical appearance. An advantage of this solution over the other two proposed approaches lies with the simplicity of HTML/VRML, which makes it suitable whenever the interaction user-management interface is limited. This is because HTML/VRML are information description languages, which cannot handle dynamic data because every time the data changes, a new HTML/VRML page has to be generated. Besides this limitation, HTML/VRML can be easily handled by basic applications started by the HTTP server and built upon simple tools such as the ones provided by the standard UNIX environment. Java [Java] and TCL [Ousterhout94] are two programming languages available on almost every platform. Java is a full-featured object-oriented programming language, whereas TCL is an interpreted scripting language. Both languages are network-aware and allow developers to create applications with a graphical appearance in a relatively short amount of time [Wayner96]. Although platform independence is usually regarded as a positive feature, it is worth mentioning that this characteristic prevents Java/TCL applications from fully interacting with the environment in which they run, namely the desktop. Java/TCL applications can hardly use local resources, print on the favourite printer or drag elements to the trashbin because they cannot reply on specific characteristics of the environment in which they run. This situation dramatically will change as soon as the Java Beans API [JavaBeans] will be fully specified. In addition Java development tools are still quite primitive and unreliable, and hence difficult to use by average programmers who are not familiar with object-oriented programming, threads, and networks. In the case of TCL it is fairly difficult to build relatively large applications due to the intrinsic language limitations. Although this situation is likely to change in the near future, Java/TCL are not yet suitable for developing large applications which have to closely interact with the local environment and be developed by average skilled programmers.

Applications developed using a RAD tool are very simple to develop and maintain because the development environment masks the complexity and helps the developer during the graphical construction of the application. Additionally these applications are not meant to be platform independent, so they can fully exploit the local environment. In conclusion, RAD tools are preferable to Java/TCL whenever the emphasis is placed on the development complexity/cost and desktop integration rather than on portability. The following section covers the design and the implementation of a management application developed by the author which enables average skilled developers to rapidly create management applications.

4. Rapid Management Application Development using Liaison

Webbin is a research project which aims to simplify the way network management is performed. Webbin is based on the idea that the complexity of protocols such as CMIP or SNMP has to be hidden by the system and that the users have to rely on the services provided by the system and to reuse them every time a new application has to be developed instead of replicating them (craftsman paradigm, i.e. everything has to be custom built for a certain task). The core element of Webbin is a software application called Liaison [Deri96a], a proxy application [Shapiro86] [Gamma94] which allows end-users to manage network resources through HTTP using CMIP [CMIP] and SNMP [SNMP], the two dominant network management protocols.

Figure 4: Liaisons Overview Liaison is written in C++ and allows client application to issue HTTP requests, which are translated into CMIP/SNMP protocol requests according to a defined mapping [Deri96c]. Although client applications communicate with Liaison using a standard network protocol, Liaison has been designed to be portable in order to facilitate its integration into an existing computing environment. Liaison is based on a special type of software component called droplets [Deri95], which can be added and replaced at runtime without having to stop the application. Each droplet provides one or more services which can be reused by other droplets. Among those services, Liaison includes droplets that allow CMIP/SNMP resources to be managed using HTML/VRML. Additionally Liaison provides the External Bindings, a set of C++/Java classes and C functions that communicate with further droplets by enabling programmers to develop decentralised management applications/applets [Meyer95] [Yemini91] based on the services provided by Liaison. As these

bindings are simple classes/functions which build URLs sent to Liaison and handle the responses, they are quite light (about 20 Kbytes in total). Hence they enable the creation of very light applications based on the services provided by a remote Liaison.

4.1 Development of HTML/VRML-based Management Applications

HTML/VRML applications are built by exploiting the basic HTML/VRML-based CMIP/SNMP management facilities offered by Liaison. Developers can: create HTML pages that contain HTML anchors pointing to URLs defined in the format accepted by Liaison; develop new droplets or applications in order to implement the missing functionality; exploit the shell commands provided with Liaison and based on the external bindings which allow simple CMIP/SNMP operations to be performed. As HTML is quite powerful and easy to use, average programmers can rapidly create applications without having to learn complex development tools but simply by composing URLs.

4.2 Development Management Applications using Java/TCL

Java external bindings [Deri96d] enable the development of Java applets/applications in a simple way using a string value representation. These applets are able to manage CMIP/SNMP resources exploiting Liaisons services. Unfortunately the creation of Java applications is still rather complicated and based on the craftsman paradigm that everything has to be custom built for a certain task. Recently, the Java community acknowledged that it is necessary to enable the creation of software components, called beans [JavaBeans], that can be reused for various applications. Although this seems the preferred way to create Java components, the beans are not extremely simple to develop and do not allow developers to build applications visually (as of today). It is the authors opinion that it is necessary to enable the visual composition of Java applications and that the classic edit-compile-link time can be reduced by creating a development environment in which the modifications can be tested while the application is being developed. In any case there is a large variety of Java development tools available on the market which facilitate the visual creation of applications and allow graphical user interfaces to be built in a matter of minutes. Similar considerations can be applied to the development of C++ applications that exploit the C++ version of the external bindings. In the case of TCL, it is possible to attach management capabilities by using the C version of the bindings, covered in the next section. Although TCL comes with the Tk toolkit, which significantly simplifies the development of graphical applications, it suffers from the lack of a standard way to reuse code or to produce reusable components in order to reduce the development time/effort. This limits reuse to library level, which is quite primitive and not always straightforward. Nevertheless the ability of TCL to write code by binding small programs into large applications is a way to reuse code to some extent and benefit from the many TCL programs/libraries freely available on the network. Finally the advanced GUI facilities offered by Tk make it reasonably simple to build network graphical applications in a fraction of the time it takes to do so with conventional

development tools and languages.

4.3 Development of Management Applications Using RAD Tools

The development of applications using RAD tools is probably the most interesting and promising way to build management applications rapidly because RAD tools: allow development time to be reduced dramatically; are so simple to use that even an average programmer can create an outstanding application. An application that formerly would have required several months of a skilled programmers time, can now be done by an average developer in a matter of weeks (see below). Unfortunately RAD tools hardly ever used in the area of network management basically because of the lack of facilities necessary to "glue" the RAD environment to the management environment. In order to fill this gap, Liaison provides C External Bindings, which are basically a C interface on top of the C++ bindings packaged in a DLL (Dynamic Loadable Library) in order to be easily called from within the RAD environment. Additionally the C bindings come with a set of files, which can be used with widely used Pascal/Basic environments, and some basic examples, which allow developers to become productive quickly.

Figure 5: Liaisons C External Bindings C bindings provide a set of functions (the total size of C bindings is about 30 Kbytes) that allow developers to take advantage of CMIP and SNMP from within the RAD environment. The bindings are quite small because they rely on the functionality of Liaison, which is supposed to run on a machine reachable from the network. In order to make the development as simple as possible, the bindings use a string representation for datatypes and offer facilities for accessing metadata. The bindings are multithread-aware and take care of the memory management. In other words the bindings include a simple garbage collector, which ensures that the strings passed/returned from/to the application are correctly freed. This feature also simplifies the application development because programmers do not have to allocate/free the memory of the strings used to communicate with the bindings and makes the application more robust because it prevents the application from crashing due to bad memory management. In addition the parameters passed to the bindings are carefully verified in order to eliminate the risk of crashing the entire application in case a bad value is passed to the bindings.

The overhead due to the use of Liaison (mapping C bindingsURLLiaisonCMIP/SNMP) instead of a direct C bindingsCMIP/SNMP mapping is less than 10-15% and is significantly lower in the case of a multithreaded application in which requests are issued concurrently. It is worth mentioning that the use of Liaison has many other advantages with respect to the latter solution: the bindings size is very small because they basically contain the garbage collector and a set of functions based on the C++ bindings (i.e. the actual processing is performed by Liaison); Liaison handles the metadata, stores network events on behalf of the bindings (event reports and traps) and handles the communication with the OSI stack (in the case of CMIP). This helps keep the binding structure simple and uses very little memory on the application side; multiple Liaisons running on different machines can be accessed by a single application based on the C bindings in order to exploit Liaisons distributed architecture and to deliver the performance the application needs; bindings are very simple, do not rely on a specific OS and can run on almost any platform. Thus they are likely to support heavy protocols such as CMIP on platforms without OSI support and to manage networks using machines of limited computing power; bindings can be easily modified and rewritten in another programming language (SmallTalk, FORTRAN, Objective C) to allow developers to use their favourite language. They also facilitate the integration of management capabilities into existing legacy code. In order to demonstrate how easily and fast applications can be developed using RAD tools, an example is shown below.

Figure 6: Simple SNMP MIB Explorer This simple SNMP MIB explorer allows one to manipulate the SNMP MIB of a remote host by exploiting the services of Liaison, which can run on a local or a remote host. Similar applications which support the CMIP protocol have been also developed by the author. This application has been written by an average programmer in a couple of hours and it has the look and feel of the operating system on which it runs. The same application written using different tools or a different language would have been much more difficult to write and it would have required a much more skilled programmer with deep knowledge of the underlying operating system. The integration in the desktop environment has several advantages. Functions such as cut and past, move, drag and drop are immediately available at no extra cost and the application behaves and looks as any other application running on the same operating system. Additionally it is possible to script the application or to use it as building block for a more complex application.

5. Final Remarks
This work attempted to demonstrate that the development of management platform is no longer an expensive task requiring highly skilled programmers and that it can be used for generic application development employing appropriate tools able to mask the complexity of network management. Liaison provides three ways to develop management applications including a new method for rapid application development. Developers can select the way management applications are created, depending on the user needs and the global application requirements: HTML/VRML for simple static applications accessible remotely using inexpensive Web browsers; Java/TCL for the development of platform-independent applications, which make use of external bindings in order to add management capabilities without incurring high costs in terms of development time, application complexity and size (quite important if the application has to be downloaded on demand); RAD tools, which allow average programmers to develop outstanding applications at a fraction of the time/cost needed to develop the same application using traditional methods. The era in which "one management platform does everything" is about to end and will be replaced with one that enables developers to build needed management applications easily. This does not mean that large and powerful management platforms will disappear because these applications constitute the backbone of corporate management systems. It means that in the future, end-users will increasingly demand tools that allow them to write the applications they need, tuned to their environment instead of delegating this task to specialised and expensive developers. One of the reasons for the limited diffusion of management tools lies with the cost of the tools and their extreme complexity. This work is a small contribution towards the construction of simple and powerful network management tools that can be used by many people and not only by rich or large organisations but also by universities and small institutions.

6. Acknowledgments
The author would like to thank Eric Van Hengstum and Dieter Gantenbein for their suggestions and valuable discussions other than the users of Webbin who have greatly stimulated with all their comments and suggestions.

7. References
[CMIP] [Deri95] [Deri96a] [Deri96b] [Deri96c] International Standards Organization, Information Technology - OSI, Common Management Information Protocol (CMIP) - Part 1: Specification, CCITT Recommendation X.711, ISO/IEC 9596-1, 1991. L. Deri, Droplets: Breaking Monolithic Applications Apart, IBM Research Report RZ 2799, September 1995. L. Deri, Network Management for the 90s, Proceedings of ECOOP 96 Workshop on System and Network Management, Linz, Austria, July 1996. L. Deri, Yasmin: a Component-based Architecture for Software Applications, December 1996. L. Deri, HTTP-based SNMP and CMIP Network Management, Internet Draft, November 1996.

L. Deri, Network Management for the 90s, Workshop Proceedings of ECOOP 96. Linz, Austria, July 1996. E. Gamma, R. Helm, R. Johnson and J. Vlissides, Design Patterns: Elements [Gamma94] of Reusable Object-Oriented Software, Addison-Wesley, 1994. IBM Corporation, IBM TMN Products for AIX: General Information, [IBM_TMN] Release 2, GC 31-8016-00, March 1996. Sun Microsystems, JavaBeans: API Specification, Version 1.00A, JavaSoft, [JavaBeans] December 1996. Sun Microsystems, The Java Programming Language, Addison-Wesley, [Java] 1995, ISBN-0-201-63455-4. [JMAPI] Sun Microsystems, Java Management API (JMAPI), Draft, 1996. [Joch96] A. Joch, Killer Components, Byte Magazine, January 1996. K. Meter, M. Erlinger, J. Betser, C. Sunshine, G. Goldszmidt and Y. Yemini Decentralizing Control and Intelligence in Network Management, [Meyer95] Proceedings of Int. Symposium on Integrated Network Management, May 1995. O. Nierstrasz, S. Gibbs and D. Tsichritzis, Component-Oriented Software [Nierstrasz92] Development, Communications of the ACM, Vol. 35, No. 9, September 1992. O. Nierstrasz and T. D. Meijler, Research Directions in Software [Nierstrasz95] Composition, Research Report, University of Berne, May 1995. Microsoft Corporation, Object Linking and Embedding v.2 (OLE2): [OLE] Programmers Reference, Vols. 1 and 2, Microsoft Press, 1993. Apple Computer, Components Made Easy, OpenDoc Technical White [OpenDoc] Paper, March 1995. [Ousterhout94] J. Ousterhout, The Tcl Language and the Tk Toolkit, Addison-Wesley, 1994. G. Pavlou and T. Tin, A CMIS-capable Scripting Language and Associated [Pavlou96] Lightweight Protocol for TMN Applications, IEEE Communications, Vol. 34, Issue 9, September 1996. C. Schmidt and M. Sevcik, Do-It-Yourself TMN Applications by Visual [Schmidt95] Programming Methods, IEEE Communications Magazine, November 1995. J. Schnwlder and H. Langendrfer, TCL Extensions for Network [Schnwlder95] Management Applications, Computer Science Dept., University of Braunschweig, May 1995. M. Shapiro, Structure and Encapsulation in Distributed Systems: the Proxy [Shapiro86] Principle, 6th Int. Conference on Distributed Computing Systems, Boston, Mass., May 1986. J. Case, M. Fedor, M. Schoffstall and C. Davin, Simple Network [SNMP] Management Protocol (SNMP), RFC 1157, May 1990. D. Tsichritzis, Object-Oriented Development for Open Systems, Proceedings [Tsichritzis89] of IFIP 89, North-Holland, San Francisco, August 1989. [Udell94] J. Udell, ComponentWare, Byte Magazine, May 1994. G. Bell, A. Parisi and M. Pesce, The Virtual Reality Modeling Language [VRML] (VRML), Version 1.0, May 1995. P. Wayner, Net Programming for the Masses, Byte Magazine, February [Deri96d]

[Wayner96] [Yemini91]

P. Wayner, Net Programming for the Masses, Byte Magazine, February 1996. Y. Yemini, G. Goldszmidt and S. Yemini, Network Management by Delegation, 2nd Int. Symposium on Integrated Network Management, April 1991.