UML for real-time software development

Real-time software is an increasingly critical part of military and aerospace product development. This software is extremely difficult to develop because of the challenging demands of complex functionality, high performance, and mission-critical dependability. The solutions to such requirements are often concurrent and distributed.

By Garth Gullekson

ObjecTime Limited

Real-time software is an increasingly critical part of military and aerospace product development. This software is extremely difficult to develop because of the challenging demands of complex functionality, high performance, and mission-critical dependability. The solutions to such requirements are often concurrent and distributed.

In addition to the technical challenges, managers continually face the problems of bringing projects in on time, moving from document-centric to model-centric development, and attracting and retaining the qualified developers they need for such systems.

Partially addressing these challenges have been commercial off-the-shelf solutions, which pair software methodologies with associated development tools. Methodologies combine graphical object- oriented modeling languages with development processes that guide project managers in how best to use the languages, with the ultimate goal of reduced project risk (e.g., on budget, on time delivery, and making the right architectural choices).

Many methodologies

The problem is that there are many methodologies to choose from, none of them standard, and few of them optimized for the unique development challenges of real-time software development. The Unified Modeling Language (UML) for Real-Time, based on the UML standard, is a solution to this problem.

The UML is an object-oriented modeling language based on a unification of leading general-purpose modeling approaches such as Booch, OMT, and OOSE. Booch and OMT have had widespread use in the military and aerospace industries. UML combines them into a common notational and conceptual definition providing a strong emphasis on use cases, object class modeling, architecture, and component-based design.

Software engineers who represent a consortium of companies led by Rational Software Corp. of Santa Clara, Calif., have defined UML and submitted it for standardization to the Object Management Group (OMG). OMG is the leading object-oriented standards body, and in addition to creating CORBA (an important standard for distributed objects), group members recently focused on standardizing object-oriented modeling approaches.

UML is already an industry standard. With the standardization of UML, developmental projects can now safely select a single general-purpose modeling language supported by a rich set of tools and widely available training and consulting.

Framers of UML designed it so users can easily optimize the language when they need it for unique problem domains such as real time. UML for real time bases its optimizations on the ObjecTime Ltd. "Real-Time Object-Oriented Modeling" (ROOM) method. ROOM, which originated in the telecommunications industry, is a field-proven visual development language for high-end real-time software.

ROOM designers incorporated graphical features that optimize the methodology for real-time dynamic component-based systems plus a complete high-performance runtime library. Automating ROOM is a toolset with code generation and executable model capability, as well as a development process that exploits these capabilities. The creators of ROOM were also part of the definition of UML and its submission to OMG.

Several military program managers are using ROOM to provide for rapid-system and real-time software development including the RSAIIA Range Standardization and Automation Program (Lockheed Martin), and the Ballistic Missile Defense Command and Control Systems (the Ballistic Missile Defense Organization, TRW and Sparta). By using ROOM, engineers from such companies are already reaping the essential benefits of UML for real-time (e.g., real-time concepts and model execution). Since ROOM forms the basis for the real-time optimizations, users of ROOM are directly on the evolution path to UML for Real-Time.

UML for Real-Time provides valuable general-purpose modeling capabilities through the UML base (e.g., use cases and class modeling). More importantly, it provides significant advantages to real-time development projects. It builds on the value of ROOM for this domain, and extends it further by increasing the support for fault tolerance and distribution.

Language optimizations, defined via the standard UML extension mechanisms, will enable developers to deal directly with the idiosyncrasies and complexity of typical real-time software. For example, in many real-time systems the application must dynamically manage task priorities and control task scheduling. Fault detection and recovery policies often require control of the computing resources such as processors and memory on which the application is running. If tasks, schedulers, and computing resources are first-class modeling concepts, it is possible to deal with such issues directly and reliably.

Optimal concepts for the problem domain increase productivity by enabling developers to express architectures and designs in a direct and natural fashion (e.g., the graphical expression of concurrent objects and graphical finite state machines).

Implementation issues are also a key consideration in UML for real-time. This methodology recognizes that real-time software development has a strong focus on high-performance runtime issues, by defining a complete runtime library as part of the language. This enables software engineers to write executable models and generate code automatically. UML for real-time thus forms a complete visual development language complete enough to address the full development lifecycle (requirements through implementation through maintenance and evolution).

Software models

What are models, and why is execution so important? A model is a concrete graphical representation of the system to be developed. Software engineers construct these models from graphical concepts that are optimized for the problem domain. An executable model has concepts that are complete, consistent, and detailed enough to be compiled, executed (i.e., run on a development workstation), and tested.

Early models may use abstractions and intentionally omit detail to improve understanding. However, models do not have to be high level only; engineers can automatically translate them into implementations. During execution, engineers can observe models using the same abstractions they used to build them. For example, they can animate state machine diagrams and message sequence charts they created to capture runtime message flow among objects. Developers can continually enhance models by using executable model feedback (i.e., problems are found by running the models as early as possible). Execution enables developers to review designs by examining the running model rather than the static documentation.

A running model provides the feedback necessary to reduce development risk. For example, the best designs are based on experience, and how developers can acquire experience quickly in new developments. A developer may face a critical component that has three apparently viable design solutions. In this situation, the developer can use executable models to create prototypes to help select the best design alternative.

During the earlier parts of the project, executable models can provide insight into requirements; they are complete and consistent enough that a developer can create basic model to confirm feature operation with customers. The net result is a substantial reduction in the risk of making poor requirement specifications, architectures, and design choices due to the immediate feedback that executable models provide.

Engineers conduct development as an iterative progression of executable models. At each stage developers concurrently integrate and verify models to ensure compliance to previously validated specifications. With UML for real-time, software designers thoroughly test the system at each stage in its development. Experts can use the same modeling concepts to create virtual test environments by simulating external software or hardware. They reduce schedule risk because execution provides concrete, testable measures of progress.

Code generation that UML for Real-Time provides delivers a trusted high-performance complete application implementation generated directly from its own detailed design model. A major advantage of this approach is incremental delivery of functionality and reduced time-to-market. Because developers generate the code directly from the design model, they avoid the error-prone and non-productive discontinuity of manually generated implementations.

Experts from Rational Software and ObjecTime are defining UML for real-time, and will promote and support the set of notational and semantic optimizations using UML`s built-in mechanisms. The definition is public domain and offered to relevant standards bodies such as OMG.

Subsequent language optimizations will further increase UML`s value for this domain via enhanced depth of support for distribution and fault tolerance. The ITU X.900 Standard Reference Model of Open Distributed Processing (RM-ODP) provides a relevant framework, nomenclature, and general concepts for optimizations. For example, RM-ODP provides an engineering view (runtime environment needed to support distributed objects including threads, distribution transparencies, communication channels, and fault tolerance mechanisms). RM-ODP forms a framework for the OMG`s CORBA standard.

Rational Software provides a process called Objectory for use with UML. Analogous to the added value that the ROOM language brings to UML, the ROOM development process will provide the basis for process optimizations to the Objectory Process for real-time projects. Such optimizations will focus on the process implications of the real-time modelingconcepts, risk items unique to real-time development, and exploit the development value of executable models and code generation.

Garth Gullekson is a chief engineer and co-founder of ObjecTime Limited in Kanata, Ontario. He developed and managed real-time telecommunications software for more than 14 years. He is a co-author with Bran Selic and Paul Ward of the ROOM method and a contributor to the UML for Real-Time definition. ObjecTime Limited may be reached by phone at 613-591-3535 or on the World Wide Web at http://www. objectime.com/.

More in Computers