HEADS Modelling Language
The HEADS Modelling language developped in WP2 is a practical model-driven software engineering tool-chain that targets resource constrained embedded systems such as low-power sensor and microcontroller based devices, gateways, and to facilitate their integration with more powerful resources (servers, cloud).
It is developed as a textual domain-specific modeling language (DSML) that includes concepts to describe both software components and communication protocols. The core concepts are a direct sub-set of the UML statecharts and component diagrams. In addition, the HEADS Modelling language provide a proper action language to implement fine-grained behavior into states and transitions, as well as an expressive template mechanism to integrate with third-party (or legacy) API, rather than re-developing them from scratch.
The HEADS Modelling Language has also been recently extended with Complex Event Processing (CEP) concepts, which allows to implement advanced behavior that is not trivial to express directly with state machines. CEP makes is possible to join or merge streams of events with no need for the developer to worry about the interleaving of those events, and buffers and timers to manage those data. Everything is handled behind the scene for the developers.
HEADS Transformation Framework
The HEADS Transformation Framework provides platform experts with a mean to implement compilers for the HEADS Modelling Language. As HEADS targets platforms and languages which should run of very heterogenous hardware ranging from microcontroller to the cloud, the framework makes it possible to define families of compilers. The framework itself is built as a modular set of classes that each compiler can reuse or redefine. This way, when a compiler has been implemented for a given language, targeting a different "dialect" on this language requires a minimal effort from the platform expert, who can reuse most of the features implemented for the main language.
Tutorials/Trainings: Github HEADS-project/training
Kevoree is an open-source dynamic component model, which relies on models at runtime  to properly support the dynamic adaptation of distributed systems. Models@runtime basically pushes the idea of reflection  one step further by considering the reflection layer as a real model that can be uncoupled from the running architecture (e.g. for reasoning, validation, and simulation purposes) and later automatically resynchronized with its running instance. Current models@runtime approaches  provide higher-level abstractions and control on top of existing component-based platforms running on powerful nodes (Java-based), with no real support for distribution. Kevoree, as described in the following, provides a solution to address the distributed and sporadic environment typically encountered in Future Internet Continuum infrastructures.
Kevoree is developed as a textual and graphical domain-specific modelling language (DSML) that includes concepts to describe both software components (configuration) and deployment topology. To this aim, it introduces the Node concept to model the infrastructure topology and the Group concept to model semantics of inter node communication during synchronization of the reflection model among nodes. The Group concept encapsulates platform synchronization algorithms. Group allows defining communication channels between nodes to propagate reconfiguration policies (i.e. new target model). This Group concept also encapsulates a dedicated protocol to ensure specific synchronization policies (e.g. Paxos derived algorithms for total order synchronization; Gossip derived algorithms for partial order and opportunistic synchronization). Groups can be bound to several nodes (named members), allowing them to explicitly define different synchronization strategies for the overall distributed system. In addition, a Group also defines a scope of synchronization, i.e. it defines which elements of the global model must be synchronized for the group’s members. This avoids sharing global models@runtime models. Kevoree includes a Channel concept to allow for multiple communication semantics between remote Components deployed on heterogeneous nodes. All Kevoree concepts (Component, Channel, Node, Group) obey the type-instance design pattern to separate deployment artifacts from running artifacts. Kevoree supports multiple kinds of execution node technology (e.g. Java, Android, MiniCloud, FreeBSD, Arduino…).
The Kevoree toolset includes text editors and graphical editor to create and edit Kevoree architectural models, a set of container to run Kevoree applications.
Kevoree is used as a language for modelling the distributed deployment of a set of software modules and as a set of runtime for managing nodes heterogeneity. The main task of Kevoree is to include Kevoree concepts in the HEADS modelling language in mixing structural Kevoree concept and ThingML behavioural concepts.
More information on how to use Kevoree is available here.
 G. S. Blair, N. Bencomo, R. B. France, Models@run.time, IEEE Computer 42 (10) (2009) 22–27.
 B. Morin, O. Barais, G. Nain, J.-M. Jezequel, Taming Dynamically Adaptive Systems with Models and Aspects, in: ICSE’09: 31st International Conference on Software Engineering, Vancouver, Canada, 2009.
Tellu participating at Vitalis 2017May 02
Tellu participated at Vitalis 2017 in Gothenburg, Sweden, on 25th-27th of April 2017.
TelluCloud innovation developed in the HEADS project at EC's stand in CEBIT 2017Mar 20
We are very glad to announce that Tellu AS has officially been selected as one of the top inn