Order to lower the adoption barriers for model based software engineering and to increase productivity in embedded systems development, we will develop an integrated model-based development environment (IMDE) for design, code generation, testing, and debugging.
Its use workflow will be refined in the project, but cover following aspects:
- Browse and read requirements from central requirements repository within the model editor
- If activated, auto-link all new model elements to selected group of requirements in all subsequent steps
Modeling from requirements, model:
- system/component interfaces as UML/SysML ports, methods, receptions
- example use cases as sequence diagrams
- assertions (e.g. safety requirements) as OCL constraints supported by usability features like auto-suggestions, specification guidance, and model „syntax“ highlighting
Test driven modeling
- model additional tests (as sequence diagrams) in the sense of test driven development. Tests will be used to verify modeled behavior later.
- use a play-in feature, where sequences can be easily filled once the test interface is defined
Model based implementation
- model behavior as state machine diagrams & activity diagrams
- use intelligent model completion support
– guided addition of elements like triggers and guards when adding transitions
– classic code completion for textual languages
– order elements in selections according to probability of selection
– improved state auto-creation when drawing transitions and vice versa (state insertion into transition, transition merging)
- get non-intrusive visual feedback on
– model consistency
– model sanity
– requirements coverage
– conflicts with existing tests and assertions (for the tests) (via model execution in background)
– generator specific feedback during modeling
- simulate and debug using visual model debugging
Test Driven model review
- for the behavior modeled, tests are generated. These tests complete coverage achievable with existing tests (for a selectable metric). One supported coverage metric is the very versatile mutation coverage (or „fault coverage“).
The new tests need to be reviewed and signed off (and related to a, possibly new, requirement)
- generated tests are checked against assertions during generation
- Code is generated and linked to model elements and thereby to requirements
- using a high quality code generator
- the generated code is adapted using optimization pattern support (e.g. for performance reasons, supporting multi-core)
- assuring tests and assertion fulfilment
- allowing manual adaptions (round trip)
Model Supported Debugging
- both manual and generated tests are run against the generated code on the target and the target is checked against assertions
- manual tests are checked against the model (back to back testing)
- unexpected behavior can be examined in debug mode in the target-debugger synced to the model debugger
- for failing tests, a shortest test case to understand the problem can be generated automatically (from the related mutations and the internal state in the model during failure)
- bug reports in a remote bug reporting system can be linked to:
– model elements
– sequence diagrams (for showing the problematic situation and to document the behavior after solving the problem.)
- test execution reports can be stamped and stored in a remote repository.
The IMDE is intended as a permissive framework and allows agile development and iterative improvements.
Integration into company-wide application life cycle management tools is not yet detailed, but will also take OSLC.