Introduction to Executable and Translatable UML

Executable and Translatable UML (xtUML) accelerates the development of real-time, embedded and technical software systems. Proven and well defined, xtUML is a fully automated methodology utilizing a UML notation.

xtUML is based on an object-oriented approach used on over 1400 real-time and technical projects. These projects include life-critical implanted medical devices, DOD flight-critical systems, 24x7 performance-critical fault-tolerant telecom systems, highly resource-constrained consumer electronics and large-scale discrete-event simulation systems.

xtUML and Accelerated Technology automation provide many benefits and capabilities including:

• Fully customizable translation that generates 100% complete, target-optimized code.
• Dramatically reduced defect rates through early execution of target-independent application models and test of application-independent designs.
• Accelerated development of products with multiple releases, growing or changing requirements, and families of products.
• Concurrent design and application analysis modeling providing compressed project schedules.
• Powerful performance tuning and resource optimization.
• Effective, practical reuse of target-independent application models.
• Effective, practical reuse of application-independent designs.
• Rapid project ramp-up resulting from a streamlined UML subset and a well-defined process.
• Reduced maintenance costs and extended product lifetimes.

xtUML leverages several key concepts that revolve around the complete separation of application and software architecture design (Figure 1):

• Application models capture what the application does in a clear and precise manner. These models are executable, providing the opportunity for early validation of application requirements. Application models are fully independent of design and implementation details.
  
  
• Software architectures, defined in terms of design patterns, design rules and implementation technologies, are incorporated into a translator that generates code for the target system. The software architectures are completely independent of the applications they support.
  
  
• The translator maps application models to the appropriate design rules and patterns resulting in 100% complete code generation for modeled components.

Figure 1:  Executable and Translatable UML development

Figure 2:  Software architecture design

No design details or target code need be developed or added for model execution. Application model execution removes system errors early, with less effort and cost, and creates an unmistakably clear exit gate: a completed application model must execute.

• A set of design patterns and translation rules (archetypes) that describe the set of patterns to be applied in code generation, when a given pattern should be used, and how xtUML model components will populate or be utilized to build code.
  
  
• A translation engine that extracts xtUML application model information, interprets the design patterns and rules, and performs the mapping of model components onto design patterns to generate complete code.
  
  
• A run-time library comprising pre-compiled routines that support the generated code modules.

Figure 3:  xtUML development

The partitioning of translators into three pieces streamlines the customization, construction and maintenance of translators. Changes and additions can be made to the design patterns, translation rules or run-time library without having to contend with the details or code of the translation engine itself.

When generating code, the translator extracts information from the xtUML application model. The translator then selects the appropriate design pattern for the "to-be-translated" model element. The information extracted from this model is then used to "fill in the blanks" of the selected design pattern. The result is a fully coded model component.

This simple approach becomes incredibly powerful for real-life applications. Population of a pattern commonly requires invocation of other patterns and rules. These newly invoked patterns and rules often, in turn, invoke other patterns and rules. The creation of code, for what appears to be one model element, can ultimately involve several nested layers of patterns and rules for multiple model elements. This is fully automated by the translator.

xtUML off-the-shelf translators are available to automatically translate 100% of the modeled system to high performance source code that is compact, easily understood and well documented. Legacy, COTS, hand-written and externally generated code is easily integrated with translator-generated code.

xtUML off-the-shelf translators support a variety of standard, pre-defined coloring options including both performance and size optimization. These open and customizable design patterns can be modified easily to provide powerful performance tuning and resource optimization to support a project's specific needs.

xtUML also simplifies repair of defects and minimizes accidental introduction of new defects into the system. If a design or implementation error is caused by a faulty translator element (pattern or rule), the error will both occur frequently and be quite visible. Such an error is easily traced back to the specific translator element that generated the defect.

Repairing the faulty translator element will quickly propagate the correction throughout all of the system's generated code automatically.

Application model errors result in defective system behavior. Because of the direct mapping between application model elements and the generated code, identification of such a defect leads directly to the specific application model element causing the problem. Fix the defective application model element and the error goes away.

Since a fix is only made at the source of the defect, fixing one problem is unlikely to introduce new problems. The introduction of side effects due to hand-coded modifications is eliminated.

The xtUML approach to system integration, test and maintenance offers an efficient means for long term support, continued defect fixes, addition of functionality and performance tuning. With xtUML, these activities do not result in increasingly fragile or "brittle" code. Fixes or changes at the application model or software architecture design level always generate clean, concise, well-documented and structured code-without developing the convoluted structure and out-of-sync application analysis, design and code that can result from code-level modifications.

xtUML is proven and effective. It has been used for large-scale telecommunication systems with over four million lines of C++ as well as implanted medical devices with memory measured in Kbytes. It has been used successfully in performance-critical, flight-critical, safety-critical, life-critical, resource-constrained and cost-constrained systems.

Direct benefits of xtUML and Accelerated Technology's automation tools include compressed project schedules, reduced software defect rates, optimized system performance and highly compact code. xtUML also accelerates development of products with multiple releases, growing or changing requirements, multiple targets and families of products. Quality is increased and development accelerated by reuse of pre-tested applications, application components and designs. Companies can compete more aggressively and effectively for customers, contracts, and market share on a pricing, time to market and product quality basis.