Introduction
New software-development toolsets enable software engineers to greatly accelerate delivery of high-quality software for real-time applications.

Graphical modeling
Using real-time software development tools, developers build graphical models of the system's structure and behavior that offer a high-level and easy-to-understand means of communicating requirements and design concepts to team members, management and customers.

Executable models
Executable models enable an iterative development process to be applied to large, complex projects. At every stage in development, developers can animate their models and actually observe the design running as the models execute.

Automatic code generation
Most tools that automatically generate code have been superficial at best, generating a mere 20 percent of the application. The latest toolsets, however, can generate 100 percent of the code needed for implementation.

Introduction
(Back to top)

Developers of software for real-time applications face a daunting list of challenges. Not only do they contend with the general hurdles of software development ever-shorter product life cycles for increasingly complex systems, and intense cost pressures they must also cope with the inherent complexity of real-time system development.

Real-time systems have four characteristics that further complicate the life of software designers: concurrency, unpredictable events, variable loading, and memory and processing limitations on target platforms.

Concurrent, event-driven real-time systems are extremely complex to specify and develop because, by definition, many interdependent operations occur simultaneously.

It is impossible to predict with certainty when or how particular real-time events will occur, what their relative order of occurrence will be, and how long they will last. Yet embedded systems must respond to events within a specified, predictable time limit.

The fluidity of a real-time embedded system's external environment is another source of complexity. An example is a telephone switch that must be designed to handle the stress of exceptionally heavy traffic on Mother's Day, yet still be cost-effective to operate. Often this means developing priority-driven software that drops less essential tasks during peak periods.

For almost every application, finite memory and processing capabilities are a challenge. For real-time software in embedded systems, these challenges can be nearly overwhelming. A controller for the handset of a portable phone, for example, may have less than 50K of storage and use an inexpensive microprocessor.

Together these characteristics have caused development delays, quality challenges and cost overruns during development of real-time software. While a host of general-purpose development languages, methodologies, and tools have appeared during the past decade to support object-oriented programming, users were unable to find complete satisfaction with any one approach. Faced with the inadequacies of using general-purpose tools to write real-time applications, software vendors developed an iterative, incremental development process and object-oriented toolsets exclusively for real-time development.

These new software-development toolsets enable software engineers to greatly accelerate delivery of high-quality software for real-time applications. For example, such tools helped a team of software engineers from Celcore Inc. of Memphis, Tenn., cut 80 percent of the time required to develop, implement and test a cellular switch, eliminating 120 person-years from their timetable. Typically, other development teams using these new toolsets report up to 50 percent reductions in development-cycle times and significant quality improvements.

To achieve these results, software engineers use toolsets built specifically for developing real-time applications. These toolsets are now being used by telecommunications, data communications, and aerospace companies to accelerate delivery of real-time software for embedded systems. Generally, these toolsets are integrated visual-development environments, including graphical editors, a model compiler and code generator, visual debugger, and version-control modules, as well as simulation and target run-time systems.

But how does a software development toolset meet the specific needs of developers of real-time applications? Three primary capabilities are crucial: a graphical modeling environment to manage design complexity, executable models to eliminate defects and provide immediate feedback on design concepts, and automatic code generation to produce complete applications from the design model.

Graphical modeling
(Back to top)

Using real-time software development tools, developers build graphical models of the system's structure (the components and how they interact) and behavior (the system's response to events). These models offer a high-level and easy-to-understand means of communicating requirements and design concepts to team members, management and customers. This capability is particularly helpful when new members join the team. They quickly become familiar with the design without needing to review lines of code in search of the big picture.

The concepts underlying the graphical modeling environments are chosen specifically to address real-time software issues such as concurrency, the unpredictability of the real-time world, distributed processing and the need for fail-safe response times. For example, some tools use concurrent objects that communicate asynchronously via message passing to define the system's architecture. Such concurrent objects also have the strongly-typed interfaces fundamental for creating distributed systems and enabling distributed development. Incorporating this approach allows designers to model complex systems and reuse objects developed by other work teams. To further reflect the dynamic nature of real-time systems, some real-time development tools now support the modeling of dynamic and replicated objects and systems. As a result, designers can create and test models that truly reflect the final implementation.

Many tools have hierarchical design concepts that enable developers to build models that can be viewed in varying levels of detail. This approach allows developers to deal only with the complexity necessary to complete a task. For example, they can focus on high-level structure and behavior rather than being inundated with excess details. If required, however, details can easily be viewed by focusing on the appropriate level.

The hierarchy is important in another key context: such tools use hierarchical state machines to model how a system reacts to events. This is a powerful mechanism for modeling reactions to external events and for managing the complexity of these relationships.

Executable models
(Back to top)

Executable models are another significant technology for software developers. This enables an iterative development process to be applied to large, complex projects. At every stage in development, developers can animate their models and actually observe the design running as the models execute.

The iterative development process is a work-style approach in demand by software developers build a little, test, build a little more, then test again. In this way, developers cycle quickly through phases of analysis and design while continuously delivering increments of functionality. Even under the pressure of escalating complexity, design concepts are proven and optimized early in the design process. This early and continuous feedback can eliminate a host of costly errors later in the development cycle. It also means designers can continually explore alternatives and refine their designs with the certainty that they will work in the real world.

Executable models also allow developers to make use of a powerful capability graphical debugging. Application designers can run models quickly and effortlessly to test alternatives. Then, as the model is refined, they can apply increasing degrees of real-world stresses to test how the system reacts to randomly-generated events and out-of-bounds values. This makes it possible to explore the effects of concurrency, variable loads and unpredictable event duration, sequence and timing.

For some real-time development toolsets, this graphical debugging concept extends beyond development environments to the target. And tight integration with third-party environments, such as Tornado from Wind River Systems, Inc. (Alameda, Calif.) automates the process of moving design models to the target, enables the models to be controlled and animated from the development platform, and combines source-code debugging with higher-level, graphical debugging. This dramatically decreases the time required for on-target debugging.

Automatic code generation
(Back to top)

In an era of shrinking time-to-market, rapid product obsolescence, and diminishing resources, automatic code generation has become mandatory. But most tools that automatically generate code have been superficial at best, generating a mere 20 percent of the application. They can generate skeletons and headers, but designers still need to do significant amounts of hand-coding. The latest toolsets, however, can generate 100 percent of the code needed for implementation.

How is it done? As developers use the graphical interface to build models, the toolsets capture the structure, behavior, data and communication paths of the application. These formal definitions are converted automatically to C++ code, much as today's compilers automatically produce machine-language code from higher-level languages.

The principle of using formal definitions, or formality, offers two extremely powerful capabilities. In the development environment, these tools generate code and execute the model. On the target environment, the generated code is the final application -- the application is complete when the model is complete. As a result, the typical disconnect between design and implementation and the time-consuming, error-prone process of writing code by hand is eliminated.