Modern software development processes include more or less comprehensive analysis and design phases where various models describing the static structure and the dynamics of a system are created. The primary motivation is to gain a deeper understanding (for discussions with developers and other stakeholders) and to provide documentation for the system. Starting from these models, the implementation is created. Unfortunately, these models are often not maintained during later phases of the project which leads to divergence of technical documentation and the final implementation, which furthermore impedes system maintenance.

Model Driven Development tries to bridge the gap between analysis/design and implementation by enriching the design artifacts (e.g. UML 2 models) to enable building parts of the application out of these models automatically. A recent initiative, called MDA (Model Driven Architecture), even has the ultimate goal to generate the whole application out of models. MDA proposes to differentiate between platform independent models (PIMs) which descibe the systems’ functionality independently of the underlying technical infrastructure. These models are then transformed by tools and transformation languages to platform specific models (PSMs), which include information about specific technology, e.g. Java/C# or MySQL/Oracle.

In concretizing the idea of model-driven development, it becomes obvious that the graphical information on its own is not sufficient to properly describe the functionality of a system. Additional languages have been introduced to describe imperative parts of the software, but these mostly exotic languages are only seldom used. We also think that it is not feasible to solely rely on graphical abstractions, since models quickly become too complex to understand, leading to similar effects as it is the case with unreadable code.

Starting from these problems, our approach "ActiveCharts" to Model Driven Development combines models from the analysis/design phases and regular (handwritten) code from the implementation phase in a new way. We model the control flow of an application with UML 2 activity diagrams which are interpreted by a runtime environment. Some actions (CallOperationActions) are realized in code which will be executed when the appropriate action is invoked. This technique is use for debuggin and for standalone applications by the ActiveChartsIDE. ActiveCharts for eclipse uses the interpreter for debugging purposes only and translates class diagrams and activities to runnable object code. Analysis/Design artifacts are therefore seamlessly reused for implementation which leads to narrowing the gap between these phases, better documentation and therefore easier maintenance.



  • Transformation of a PIM to a PSM (termed Java specific model JSM)
  • enhanced code generation from UML 2.0 class diagrams, supporting 
    • higher order associations
    • association classes
    • navigability of association ends
    • visibility of association ends
    • composition (with life-time control of parts)
    • methods for association management (add, remove, get, set methods)
    • multiple Inheritance (not yet implemented)
  • Interpreting UML 2.0 activity charts, supported elements include
    • initial, flow final and activity final nodes
    • fork, join, decision and merge nodes
    • callbehavior actions
    • both control and object flow
    • nested activities (i.e. activities calling other activities)
    • interruptible regions
    • accept event actions with signal trigger and time trigger
  • Code generation for Behaviours (not yet implemented) Debugging & simulating UML 2.0 activity charts