The Tribefire documentation is continuously updated and freely available (no fees, no registration) to users, including a fully working virtual machine.

Reading the submitted paper should act as a very quick summary about Cortex and Tribefire. The video on Extending The Platform is the last one of the technical base course. It describes the extension of TF given by the tribefire demo (cartridge) described in the paper (including models, expert, and configuration via wires) and should be understandable despite the technicisms of the platform.

We are working on a new set of videos about Tribefire and its new (advanced) features, that we left out from the paper due to space limitation.

The latest video is available here and its explanation is currently available as PDF document Demo 2019. The final version of this demo video will include the audio track and will be part of the training offer and will be made available on YouTube.

This is a companion public git repository of the tool demo paper submitted to Models 2019. It includes:

• Additional links to Tribefire Academy and Documentation portals
• Prototype of a Ecore2GmModel transformation.

Figure 1. The DDSA-based architecture of Tribefire.

Figure 2. The Cortex Engineering Process (CEP) where the Tribefire platform is customised to build new platforms.

A deep dive into the Cortex approach and Tribefire tool is possible via the Tribefire Academy Portal. It includes two sections, Training and Documentation, that are freely accessible.

In Training, the user is guided through the setup of a [Tribefire Virtual Machine] (https://academy.tribefire.com/license-agreement/) Sets of videos/slides/exercises are available for

• Technical Base Course.
• Front-End Development via Tribefire REST API (https://academy.tribefire.com/tribefire-tech-basics-course/) and Tribefire JavaScript API
• Tribefire Extension via Java API For convenience, [Downloads] are collected in a single page here

in Documentation, you can find detailed written explanations about TF, its features, and its cloud-based deployment. The implementation of the case study in Figure 1 is available here.

The Ecore2GmModel Prototype is a model transformation implemented in by a combination of EOL, EGL and EGX specifications, three DSLs provided by the Eclipse Epsilon framework. EOL is an imperative programming language for creating, querying and modifying EMF models. EGL is a template-based model-to-text language for generating code, documentation and other textual artefacts from models. EGX is a rule-based language for coordinating the execution of EGL templates.

The transformation takes a single input (.ecore) and generates multiple outputs, i.e., Java Interfaces representing a Data Model (data-model, see Figure 1) in the Cortex Modeling Space (see paper for further details).

Ecore2GmModel is performed in two steps. Step 1. Annotation. The first step adds a set of eAnnotations (namely GmCore) to Ecore model elements.

Step 2. Transformation. The annotations are required and used by the second step to optimise the transformation process, by enabling:

• Deletion or Replacement of EClasses and, then, update of EStructutalFeatures typed by the involved EClasses (via GmCore::ignored and GmCore::replaceBy eAnnotations).
• Replacement of Ecore PrimitiveTypes with Tribefire Simple Types (via GmCore::replaceBy eAnnotations).

The generated Java APIs can be used during the Modeling and Implementation activities of the Cortex Engineering Process outlined in the paper. In particular, the outout of the model transformation is classified as a Model Priming asset.

The transformation have been tested in many proof-of-value case studies. The output of all case studies is a set of Java Model APIs representing Data Models to be used as part of a DDSA-based extension of Tribefire (see paper for further details).

All case studies can be displayed in Tribefire via Datapedia, an internal assets (including data assets) repository developed at Braintribe.

To access Datapedia as guest users:

• Go to Datapedia
• Access as Guest User with read only access (username: DisimUser, password: disim).
• Click on Model Assets.
• Click on asseet of your choice.
• A new informative page is displayed. On the top menu click on Versions.
• An IFrame will be opened showing a Tribefire Model within a running Tribefire platform (with limited functionalities)
• The chosen model can be inspected.

Here below, we outline three running case studies where the Ecore2GmModel transformation generated the Model APIs that, once installed in Tribeifre, are parsed and generate the the corresponding in-memory representation that are finally shown in the graph-based graphical models editor.

In order to execute the transformations of the case studies, the latest version of the [Eclipse Epsilon framework] (https://www.eclipse.org/epsilon/download/) have to installed in Eclipse (preferred installation package Eclipse Modeling Tools)

Db.ecore is a simple Ecore Model defining the generic structure of a DB in Ecore. The DB.ecore model (available in Ecore2GmModel/model/DB.ecore) is annotated with GmCore annotations. No values are added to annotations and they do not influence the generation of the Java Model API for TF.

Run the case study:

1. Copy paste the Ecore2GmModel/model/DB.ecore in Ecore2GmModel/model/annotated/ (overwrite if asked).
2. Run Ecore2GmModel/launchers/DB/DB_Step1_Annotation.launch. Ecore2GmModel/model/annotated/DB.ecore is annotated with GmCore.
3. Run DB_Step2_Java_ModelAPI_Generation.launch. Ecore2GmModel/model/annotated/DB.ecore is converted to Java Model API for TF. The output is generated in Ecore2GmModel/transformations/output/db folder. The db folder is a valid source code package that can be copied in a Tribefire Cartridge as part of Model Priming platform asset.

ISO 20022 is the Universal financial industry message scheme. The Ecore (meta)model is available here. The ISO 20022.ecore model (available in Ecore2GmModel/model/ISO20022.ecore) is annotated with GmCore annotations. No values are added to annotations and they do not influence the generation of the Java Model API for TF. It is not optimised since it defined primitive types (e.g. String) that should be replaced by Tribefire Simple Types.

Run the case study:

1. Copy paste the Ecore2GmModel/model/ISO20022.ecore in Ecore2GmModel/model/annotated/ (overwrite if asked).
2. Run Ecore2GmModel/launchers/ISO20022/ISO20022_Step1_Annotation.launch. Ecore2GmModel/model/annotated/ISO20022.ecore is annotated with GmCore.
3. Run ISO20022_Step2_Java_ModelAPI_Generation.launch. Ecore2GmModel/model/annotated/ISO20022.ecore is converted to Java Model API for TF. The output is generated in Ecore2GmModel/transformations/output/iso20022 folder. The iso20022/ folder is a valid source code package that can be copied in a Tribefire Cartridge as part of Model Priming platform asset.

HL7 FHIR Fast Healthcare Interoperability Resources (FHIR®, pronounced "fire") is a next generation standards framework that leverages the latest web standards and applies a tight focus on implementation and was developed by healthcare standards developing organization, Health Level Seven International (HL7). The fhir.ecore model is obtained from the XSD specification publicly available here. It has been converted in Ecore thanks to the built-in XSD2Ecore transformation. The output is not optimised and many antipatterns should be removed. The antipattern detection is performed by Ecore2GmModel/transformations/epsilon/eol/Step1Annotation/FhirSpecificGmCoreAnnotations.eol, a specialisation of Ecore2GmModel/transformations/epsilon/eol/Step1Annotation/GenericGmCoreAnnotation.eol.

Run the case study:

1. Copy paste the Ecore2GmModel/model/fhir.ecore in Ecore2GmModel/model/annotated/ (overwrite if asked).
2. Run Ecore2GmModel/launchers/ISO20022/FHIR_Step1_Annotation.launch. Ecore2GmModel/model/annotated/fhir.ecore is annotated with GmCore.
3. Run FHIR_Step2_Java_ModelAPI_Generation.launch. Ecore2GmModel/model/annotated/fhir.ecore is converted to Java Model API for TF. The output is generated in Ecore2GmModel/transformations/output/fhir folder. The fhir/ folder is a valid source code package that can be copied in a Tribefire Cartridge as part of Model Priming platform asset.