Lessons Learned Building OO Telecommunication Software

Douglas C. Schmidt
Department of Computer Science
Washington University, St. Louis
http://www.cs.wustl.edu/~schmidt/
schmidt@cs.wustl.edu

An earlier version of this article appeared in the Lucent Bell Labs ``Multiuse Express'' magazine, Vol. 4, No. 6, December, 1996.


The Distributed Software Crisis

Developing complex software systems is expensive and error-prone. Object-oriented (OO) programming languages [Stroustrup:91,Gosling:96], components [Box:97], and frameworks [Lewis:95] are heavily touted technologies for reducing software cost and improving software quality. When stripped of their hype, the primary benefits of OO stem from the emphasis on modularity and extensibility, which encapsulate volatile implementation details behind stable interfaces and enhance software reuse.

Developers in certain well-traveled domains have successfully applied OO techniques and tools for years. For instance, the Microsoft MFC GUI framework and OCX components are de facto industry standards for creating graphical business applications on PC platforms. Although these tools have their limitations, they demonstrate the productivity benefits of reusing common frameworks and components.

Software developers in more complex domains like telecom have traditionally lacked standard off-the-shelf middleware components. As a result, telecom developers largely build, validate, and maintain software systems from scratch. In an era of deregulation and stiff global competition, this in-house development process is becoming prohibitively costly and time consuming. Across the industry, this situation has produced a ``distributed software crisis,'' where computing hardware and networks get smaller, faster, and cheaper; yet telecom software gets larger, slower, and more expensive to develop and maintain.

The challenges of building distributed software stem from inherent and accidental complexities [Brooks:87] associated with telecom systems:

The lack of extensibility and reuse in-the-large is particularly problematic for complex distributed telecom software. Extensibility is essential to ensure timely modification and enhancement of services and features. Reuse is essential to leverage the domain knowledge of expert developers to avoid re-developing and re-validating common solutions to recurring requirements and software challenges.

While developing high quality reusable software is hard enough, developing high quality extensible and reusable telecom software is even harder. Not surprisingly, many companies attempting to build reusable middleware fail -- often with enormous loss of money, time, and marketshare. Those companies that do succeed, however, reap the benefits resulting from their ability to develop and deploy complex applications rapidly, rather than wrestling endlessly with infrastructure problems. Unfortunately, the skills required to successfully produce telecom middleware remain something of a "black art," often locked in the heads of expert developers.


Lessons Learned Building Reusable OO Communication Software Frameworks

Over the past decade, I've worked with many companies (including Motorola Iridium, Ericsson, Siemens, Bellcore, Lucent, SAIC, Kodak, and Boeing) building reusable OO communication software [Schmidt:96]. In these projects, we've applied a range of OO middleware tools including OMG CORBA (an emerging industry standard for distributed object computing) and the ACE framework (a widely used C++ framework that implements many strategic and tactical design patterns for concurrent communication software). The following are lessons learned from developing and deploying reusable OO communication software components and frameworks in practice: