Axini develops tools for model based testing (MBT) and model based software engineering (MBSE). Model based testing is a software testing approach in which test cases are automatically generated and executed from a model, a formal specification of the system under test. This approach allows for a high degree of test automation and more thorough testing.
This research project is about easing the modeling phase. Especially when there are already existing systems to model and test, it can take some effort to make the initial models. This assignment, should you accept it, is all about getting an automated head start with the modeling.
- One topic that we are interested in is converting design artefacts to Axini models. For example, the transformation of a UML or SysML model into Axini. This is called model to model transformation.
- Another topic is the conversion of (parts of) code/implementation into models. For example, a state machine in C or C++ or business rules in Cobol. This is called code to model transformation.
Model to model transformation
We already have a couple of use-cases that can be an inspiration or can be the actual topic of your research. For example:
- ProRail has SysML models of object controllers that operate signals, switches etc. You can use those for your research.
- Thermo Fisher and Philips have models in their respective MBSE tools Capella and Cameo. Many of these models are UML and/or SysML inspired models, such as state machines.
Some inspiration/ideas on the potential techniques to use. There are DSL (Domain Specific Language) approaches to transform languages and/or models. In this case you make a parser/translator in a tool such as Jetbrains MPS that reads (part of) a model, deconstructs it into its essential parts and translates and generates from these parts the Axini model.
We can work together with companies specialized in language engineering such as F1re and Swat Engineering for the DSL engineering part.
Code to model transformation
We already have a couple of use-cases that can be an inspiration or can be the actual topic of your research. For example:
- ProRail has actual state machines that control the reservation of the parts of the tracks relevant for the course of the trains. These state machines are encoded in C++ code.
- Belastingdienst and UWV have decision and computation rules encoded in languages such as Cobol and Java. We would like to translate these parts into Axini models.
Just like with the model-to-model transformation, an interesting technique seems to be the use of DSLs (see above in the section model to model transformation).
In the domain of PLCs, Bas Beuting has researched the topic of PLC code transformation into UML and Axini models.
Excel to model transformation
Many organizations encode business logic in spreadsheets. The goal here is not to design a new DSL, but to build a practical assistant that imports Excel/CSV, helps users map tables to model concepts, and generates a first model + tests with clear traceability back to cells.
Things the tool could do
- Import: Read .xlsx/.csv, pick sheets/ranges, handle headers, merged cells, formatting quirks.
- Detect structure: Infer column types (numbers, enums, dates), domains, and candidate keys (e.g., ID columns).
- Map: Guide the user to map columns → model parameters and identify target outputs/decisions.
- Rule mining: Derive candidate conditions from value ranges, thresholds, and Excel formulas.
- Explain & trace: For every generated rule or transition, show the originating cells (lineage).
- Validate: Run a sample of rows as executable tests against the generated model; report mismatches.
- Iterate safely: Preview changes, diff regenerations, and allow one-click “accept/snooze/ignore”.
- Export: Produce an AML model skeleton, a test suite from rows, and a human-readable report.
Example
Suppose an Excel sheet defines a loan decision:
Income CreditScore Decision >3000 >600 APPROVE <=3000 >700 APPROVE <=3000 <=700 REJECT
The assistant would:
- Suggest Income and CreditScore as inputs; Decision as the outcome.
- Mine candidate rules (e.g., thresholds 3000 and 600/700) and show a readable rule table.
- Generate a model skeleton (states/transitions or decision table) plus tests derived from the rows.
- Provide lineage: clicking a rule highlights the exact Excel cells it came from.
- Let the user tweak mappings (e.g., rename parameters, tighten ranges) and re-generate with a diff.
AI-assisted help (optional, but powerful)
- Normalize & repair: Detect inconsistent labels (“Approved”, “APPROVE”), missing values, and ambiguous ranges; propose cleanups with confidence scores.
- Explain formulas: Summarize complex Excel formulas into natural-language conditions before turning them into rules.
- Suggest coverage: Propose edge-case rows (boundary values) that are missing from the sheet and add them as candidate tests.
Possible research questions
There are several puzzles and research questions that students can work on.
Which information in models is needed to transform them into formal AML models?
Which source code can be transformed into AML models?
How can a transformation into another model be validated?
How can we robustly infer table schemas and map columns to model parameters with minimal user input?
Which algorithms best extract readable, correct conditions from ranges, enums, and Excel formulas?
What is an effective lineage model from Excel cells to model artifacts (rules/states/transitions/tests)?
How do we automatically generate a test suite from spreadsheet rows and check the generated model against it?
Where do LLMs add the most value (normalization, formula explanation, gap-filling) without harming determinism and reproducibility?
Recent work
Recent work at Axini on this topic:
- Tobias Bachmann (2021) translated SysML models of ProRail into Axini models and used them to model based test the implementations generated from the original SysML models.