Download CodeGenie v.4.3 (released June 2005)

CodeGenie Support area

Introduction to CodeGenie (pdf)

Read how Domain Solutions helped AMS (pdf)

What is CodeGenie?

Domain Solutions' CodeGenie turns models into code. It supports the Executable UML process within the Object Management Group Model Driven Architecture approach for automatic code generation from object-oriented UML analysis models. CodeGenie can be fully customised to accommodate the client's chosen software processes, target software architecture, software development environment and configuration management tools. CodeGenie is focussed on translating UML application models to software. It replaces the often simple generation offered by the well-known CASE tools which have hard-coded and inadequate rules for code generation that do not support the desired software architecture.

What are the benefits?

The use of code generation techniques allows the analysis of the system requirements to be separated from the design. This approach provides a number of advantages over traditional methods:

• The complete set of requirements are established before coding commences.
• Design issues are separated from the application analysis
• The system may be hosted on a range of platforms.
• The UML models are executable.
• Uniform adherence to coding standards.
• Mid to long-term cost and time saving.
• CASE tool independence through XMI input.

CodeGenie delivers:

• Higher software quality by consistently applying design constraints.
• Shorter time-to-market as the total process time is shorter.
• Architectural and design flexibility since the analysis and architecture are separated.
• Re-use of analysis and architecture models.
• Analysis models are complete and can be simulated and verified for consistency and completeness

CodeGenie toolset:

The code generation tools are based on our generic executable UML and architecture meta models. As with compiler-compilers the tool is used to generate itself! The toolset consists of:

• Model Reader. Reads model content from the major CASE tools into our meta-model.
• Model Browser. A Java graphical interface to browse and display the meta-model content.
• Model Auditor. Checks executable UML models for completeness and consistency.
• CodeGenie generator. An archetype-based code generator to generate the software for application models from an architecture meta-model.

Levels of code generation

Code generation is supported at three levels:
1. Simple language dependant code-frames.
2. Code-Frames with OOA mechanisms.
3. Full model translation and an action language.

Which CodeGenie generator?

CodeGenie delivers an off-the-shelf solution for C++/Java for an architecture with a persistent single server supporting multiple clients. It is easy to extend this architecture model and the software produced by using Java Archetype (JARC) files. JARC files combine literal text and substitution statements that provide a template for producing any code (C++/Java etc) or other output e.g. documentation from the populated meta-models.

What is generated?

• Static Application Generation: generating the static structure of the application from the OOA meta-model, e.g. class definitions etc.
• Mechanistic Architecture Generation: generating the architectural mechanistic elements of the code from the Architecture meta-model, e.g. event queues.
• Dynamic Application Generation: generating the application's run time dynamic behaviour for methods/state actions. These are written in language neutral abstract C++ or Java and can use an Action Language library for OOA mechanisms e.g. finds.

Running CodeGenie

1. Export the UML model in XMI from the CASE tool. This is used to populate the OOA meta-model.
2. Populate the software architecture from the OOA meta-model elements, e.g. persistent items etc.
3. Interpret the CodeGenie JARC files to produce the software for the system, and build the system.