Publications

Journals | Conference-Workshop papers

Journals

Safe model polymorphism for flexible modeling, Computer Languages, Systems & Structures, Volume 49, Elsevier, In Press, Corrected Proof, Available online 21 September 2016, DOI: 10.1016/j.cl.2016.09.001

Authors: Thomas Degueule, Benoit Combemale, Arnaud Blouin, Olivier Barais, Jean-Marc Jézéquel

Abstract: Domain-Specific Languages (DSLs) are increasingly used by domain experts to handle various concerns in systems and software development. To support this trend, the Model-Driven Engineering (MDE) community has developed advanced techniques for designing new DSLs. However, the widespread use of independently developed, and constantly evolving DSLs is hampered by the rigidity imposed to the language users by the DSLs and their tooling, e.g., for manipulating a model through various similar DSLs or successive versions of a given DSL. In this paper, we propose a disciplined approach that leverages type groups׳ polymorphism to provide an advanced type system for manipulating models, in a polymorphic way, through different DSL interfaces. A DSL interface, a.k.a. model type, specifies a set of features, or services, available on the model it types, and subtyping relations among these model types define the safe substitutions. This type system complements the Melange language workbench and is seamlessly integrated into the Eclipse Modeling Framework (EMF), hence providing structural interoperability and compatibility of models between EMF-based tools. We illustrate the validity and practicability of our approach by bridging safe interoperability between different semantic and syntactic variation points of a finite-state machine (FSM) language, as well as between successive versions of the Unified Modeling Language (UML).

Model-Based Software Engineering to Tame the IoT Jungle, IEEE Software, Volume 34, Issue 1, Jan.-Feb. 2017, IEEE, Pages 30 - 36, DOI: 10.1109/MS.2017.11

Authors: Brice Morin, Nicolas Harrand, Franck Fleurey

Abstract: The Internet of Things (IoT) is a challenging combination of distribution and heterogeneity. A number of software engineering solutions address those challenges in isolation, but few solutions tackle them in combination, which poses a set of concrete challenges. The ThingML (Internet of Things Modeling Language) approach attempts to address those challenges. This model-driven, generative approach, which was inspired by UML, integrates concepts targeted at the IoT. Over the past six years, it has been continuously evolved and applied to cases in different domains, including a commercial e-health solution.

ScapeGoat: Spotting Abnormal Resource Usage in Component-based Reconfigurable Software Systems, Journal of Systems and Software, Volume 122, Elsevier, December 2016, Pages 398–415, DOI: 10.1016/j.jss.2016.02.027

Authors: I. Gonzalez-Herrera, J. Bourciera, E. Dauberta, W. Rudametkinb, O. Baraisa, F. Fouquetc, J.M. Jézéquela, B. Baudrye

Abstract: Modern component frameworks support continuous deployment and simultaneous execution of multiple software components on top of the same virtual machine. However, isolation between the various components is limited. A faulty version of any one of the software components can compromise the whole system by consuming all available resources. In this paper, we address the problem of efficiently identifying faulty software components running simultaneously in a single virtual machine. Current solutions that perform permanent and extensive monitoring to detect anomalies induce high overhead on the system, and can, by themselves, make the system unstable. In this paper we present an optimistic adaptive monitoring system to determine the faulty components of an application. Suspected components are finely analyzed by the monitoring system, but only when required. Unsuspected components are left untouched and execute normally. Thus, we perform localized just-in-time monitoring that decreases the accumulated overhead of the monitoring system. We evaluate our approach on two case studies against a state-of-the-art monitoring system and show that our technique correctly detects faulty components, while reducing overhead by an average of 93%.

Multitier Diversification in Web-Based Software Applications, IEEE Software (journal article), Volume 32 (Issue 1), IEEE, Jan.-Feb. 2015, Pages 83-90 DOI: 10.1109/MS.2014.150

Authors: Allier, S. ; Barais, O. ; Baudry, B. ; Bourcier, J. ; Daubert, E. ; Fleurey, F. ; Monperrus, M. ; Hui Song ; Tricoire, M.

Abstract: Web application development benefits massively from modular architectures and reuse. This excellent software engineering practice is also the source of a new form of monoculture in application-level co de, which creates a potential risk for dependability. Researchers propose using software diversification in multiple components of Web applications to reconcile the tension between reuse and dependability. This article identifies key enablers for the effective diversification of software, especially at the application-code level. It's possible to combine different software diversification strategies, from deploying different vendor solutions to fine-grained code transformations, to provide different forms of protection.

Conference-Workshop papers

Process architecture enabling object orientation and dynamic configuration for small embedded devices, 7th International Joint Conference on Pervasive and Embedded Computing and Communication Systems (PECCS 2017), 24-26 July 2017, Madrid, Spain, SCITEPRESS Digital Library, To appear

Authors: Steffen Dalgard, Anders E. Liverud

Automatic non-functional testing of code generators families, Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE 2016), October 31 - November 01, 2016, Amsterdam, Netherlands, ISBN: 978-1-4503-4446-3, ACM, 2016, Pages: 202-212 , DOI: 10.1145/2993236.2993256

Authors: Mohamed Boussaa, Olivier Barais, Benoit Baudry, Gerson Sunyé

Abstract: The intensive use of generative programming techniques provides an elegant engineering solution to deal with the heterogeneity of platforms and technological stacks. The use of domain-specific languages for example, leads to the creation of numerous code generators that automatically translate highlevel system specifications into multi-target executable code. Producing correct and efficient code generator is complex and error-prone. Although software designers provide generally high-level test suites to verify the functional outcome of generated code, it remains challenging and tedious to verify the behavior of produced code in terms of non-functional properties. This paper describes a practical approach based on a runtime monitoring infrastructure to automatically check the potential inefficient code generators. This infrastructure, based on system containers as execution platforms, allows code-generator developers to evaluate the generated code performance. We evaluate our approach by analyzing the performance of Haxe, a popular high-level programming language that involves a set of cross-platform code generators. Experimental results show that our approach is able to detect some performance inconsistencies that reveal real issues in Haxe code generators.

ThingML: a language and code generation framework for heterogeneous targets, Proceedings of the ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), October 2-7, 2016, Saint-malo, France, ISBN: 978-1-4503-4321-3, ACM, 2016, Pages: 125-135 , DOI: 10.1145/2976767.2976812

Authors: Nicolas Harrand, Franck Fleurey, Brice Morin, Knut Eilif Husa

Abstract: One of the selling points of Model-Driven Software Engineering (MDSE) is the increase in productivity offered by automatically generating code from models. However, the practical adoption of code generation remains relatively slow and limited to niche applications. Tooling issues are often pointed out but more fundamentally, experience shows that: (i) models and modeling languages used for other purposes are not necessarily well suited for code generation and (ii) code generators are often seen as black-boxes which are not easy to trust and produce sub-optimal code. This paper presents and discusses our experiences applying the ThingML approach to different domains. ThingML includes a modeling language and tool designed for supporting code generation and a highly customizable multi-platform code generation framework. The approach is implemented in an open-source tool providing a family of code generators targeting heterogeneous platforms. It has been evaluated through several case studies and is being used for in the development of a commercial ambient assisted living system.

NOTICE: A Framework for Non-Functional Testing of Compilers, 2016 IEEE International Conference on Software Quality, Reliability and Security (QRS), 1-3 August, Vienna, Austria, INSPEC Accession Number: 16378531, IEEE 2016, Pages: 335-346, DOI: 10.1109/QRS.2016.45

Authors: Mohamed Boussaa, Olivier Barais, Benoit Baudry, Gerson Sunyé

Abstract: Generally, compiler users apply different optimizations to generate efficient code with respect to non-functional properties such as energy consumption, execution time, etc. However, due to the huge number of optimizations provided by modern compilers, finding the best optimization sequence for a specific objective and a given program is more and more challenging. This paper proposes NOTICE, a component-based framework for non-functional testing of compilers through the monitoring of generated code in a controlled sand-boxing environment. We evaluate the effectiveness of our approach by verifying the optimizations performed by the GCC compiler. Our experimental results show that our approach is able to auto-tune compilers according to user requirements and construct optimizations that yield to better performance results than standard optimization levels. We also demonstrate that NOTICE can be used to automatically construct optimization levels that represent optimal trade-offs between multiple non-functional properties such as execution time and resource usage requirements.

Agile development of home automation system with ThingML, 2016 IEEE 14th International Conference on Industrial Informatics (INDIN), 19-21 July, Poitiers, France, INSPEC Accession Number: 16616107, IEEE 2016, Pages: 337-344, DOI: 10.1109/INDIN.2016.7819183

Authors: Anatoly Vasilevskiy, Brice Morin, Øystein Haugen, Pal Evensen

Abstract: Advances in the Internet of Things (IoT) domain thrusts home automation into the spotlight. Home automation is a heterogeneous realm with various and often not compatible technologies. As any not standardized area, this realm is always disrupted by new, emerging technologies and standards. Home is a dynamic environment which constantly grows and evolves. To keep up with changes, home automation algorithms are tweaked and modified over time. To tackle diversity, we employ model driven approaches to weave different technologies and facilitate home automation tasks. We show how modelling techniques improve portability, scalability and simulation of the home automation features. We present two use-cases developed in cooperation with industry partners, report our experience in applying ThingML and the Arrowhead framework in the home automation domain.

Towards microservices architecture to transcode videos in the large at low costs, 2016 International Conference on Telecommunications and Multimedia (TEMU), 25-27 July, Heraklion, Crete, Greece, INSPEC Accession Number: 16263932, IEEE 2016, Pages: 1-6, DOI: 10.1109/TEMU.2016.7551918

Authors: Olivier Barais, Johann Bourcier, Yérom-David Bromberg, Christophe Dion

Abstract: The increasing popularity of videos over Internet, combined with the wide heterogeneity of various kinds of end users' devices, imposes strong requirements on the underlying infrastructure and computing resources to meet the users expectations. In particular, designing an adequate transcoding workflow in the cloud to stream videos at large scale is: (i) costly, and (ii) complex. By inheriting key concepts from the software engineering domain, such as separation of concerns and microservice architecture style, we are giving our experience feedbacks of building both a low cost and efficient transcoding platform over an ad hoc computing cloud built around a rack of Raspberry Pis.

A Generative Middleware for Heterogeneous and Distributed Services, 2016 19th International ACM SIGSOFT Symposium on Component-Based Software Engineering (CBSE), 5-8 April, 2016, Venice, Italy, INSPEC Accession Number: 16104262, IEEE 2016, Pages: 107-116, DOI: 10.1109/CBSE.2016.12

Authors: Brice Morin, Franck Fleurey, Knut Eilif Husa, Olivier Barais

Abstract: Modern software-based services increasingly rely on a highly heterogeneous and dynamic interconnection of platforms and devices offering a wide diversity of capabilities ranging from cloud server with virtually unlimited resources down to microcontrollers with only a few KB of RAM. This paper motivates the fact that no single software framework or software engineering approach is suited to span across this range, and proposes an approach which leverages the latest advances in model-driven engineering, generative techniques and models@runtime in order to tame this tremendous heterogeneity. This paper presents a set of languages dedicated to the integration, deployment and continuous operation of existing libraries and components already available and implemented in various languages. The proposed approach is validated on an industrial case study in the eHealth domain, implemented by an industrial partner that provide an qualitative evaluation of the approach. This case study involves a large number of sensors, devices and gateways based on Rasperry Pi, Intel Edison and Arduino.

KevoreeJS: Enabling dynamic software reconfiguration in the Browser, 2016 19th International ACM SIGSOFT Symposium on Component-Based Software Engineering (CBSE), 5-8 April, 2016, Venice, Italy, INSPEC Accession Number: 16104249, IEEE 2016, Pages: 49-58, DOI: 10.1109/CBSE.2016.20

Authors: Maxime Tricoire, Olivier Barais, Manuel Leduc, Francois Fouquet, Gerson Sunyé, Brice Morin, Johann Bourcier, Grégory Nain, Ludovic Mouline 

Abstract: The architecture of classic productivity software are moving from a traditional desktop-based software to a client server architecture hosted in the Cloud. In this context, web browsers behave as application containers that allow users to access a variety of Cloud-based applications and services, such as IDEs, Word processors, Music Collection Managers, etc. As a result, a significant part of these software run in the browser and accesses remote services. A lesson learned from development framework used in distributed applications is the success of pluggable architecture pattern as a core architecture concept, i.e., a Software Architecture that promotes the use of Pluggable Module to dynamically plug. Following this trend, this paper discusses the main challenges to create a component-based platform supporting the development of dynamically adaptable single web page applications. This paper also presents an approach called KevoreeJS based on models@runtime to control browser as component platform which address some of these challenges. We validate this work by presenting the design of a dashboard for sensor based system and highlighting the capacity of KevoreeJS to dynamically choose the placement of code on the server or client side and how KevoreeJS can be used to dynamically install or remove running components.

Squirrel: Architecture Driven Resource Management, Proceedings of the 31st Annual ACM Symposium on Applied Computing (SAC'16), April 4-8, 2016, Pisa, Italy, ISBN: 978-1-4503-3739-7, ACM, 2016, Pages: 1329-1336, DOI: 10.1145/2851613.2851768

Authors: Inti Gonzalez-Herrera, Johann Bourcier, Walter Rudametkin, Olivier Barais, Francois Fouquet 

Abstract: Resource management is critical to guarantee Quality of Service when various stakeholders share the execution environment, such as cloud or mobile environments. In this context, providing management techniques compatible with standard practices, such as component models, is essential. Resource management is often realized through monitoring or process isolation (using virtual machines or system containers). These techniques (i) impose varying levels of overhead depending on the managed resource, and (ii) are applied at different abstraction levels, such as processes, threads or objects. Thus, mapping components to system-level abstractions in the presence of resource management requirements can lead to sub-optimal systems. We propose Squirrel, an approach to tune component deployment and resource management in order to reduce management overhead. At runtime, Squirrel uses an architectural model annotated with resource requirements to guide the mapping of components to system abstractions, providing different resource management capabilities and overhead. We present an implementation of Squirrel, using a Java component framework, and a set of experiments to validate its feasibility and overhead. We show that choosing the right component-to-system mappings at deployment-time reduces performance penalty and/or volatile main memory use.

A Novelty Search-based Test Data Generator for Object-oriented ProgramsProceedings of the Companion Publication of the 2015 Annual Conference on Genetic and Evolutionary Computation (GECCO Companion '15), 11-15 July, 2015, Madrid, Spain, ISBN: 978-1-4503-3488-4, ACM, 2015, Pages: 1359-1360, DOI: 10.1145/2739482.2764716

Authors: Mohamed Boussaa, Olivier Barais, Gerson Sunye, and Benoit Baudry 

Abstract: In search-based structural testing, meta-heuristic search techniques have been frequently used to automate test data generation. In this paper, we introduce the use of novelty search algorithm to the test data generation problem based on statement-covered criterion. In this approach, we seek to explore the search space by considering diversity as the unique objective function to be optimized. In fact, instead of having a fitness-based selection, we select test cases based on a novelty score showing how different they are compared to all other solutions evaluated so far.

A Novelty Search Approach for Automatic Test Data Generation, 8th International Workshop on Search-Based Software Testing (SBST) 2015, 18-19 May, 2015, Firenze, Italy, IEEE, 2015, Pages: 40-43.

Authors: Mohamed Boussaa, Olivier Barais, Gerson Sunye, Benoit Baudry

Abstract: In search-based structural testing, metaheuristic search techniques have been frequently used to automate the test data generation. In Genetic Algorithms (GAs) for example, test data are rewarded on the basis of an objective function that represents generally the number of statements or branches covered. However, owing to the wide diversity of possible test data values, it is hard to find the set of test data that can satisfy a specific coverage criterion. In this paper, we introduce the use of Novelty Search (NS) algorithm to the test data generation problem based on statement-covered criteria. We believe that such approach to test data generation is attractive because it allows the exploration of the huge space of test data within the input domain. In this approach, we seek to explore the search space without regard to any objectives. In fact, instead of having a fitness-based selection, we select test cases based on a novelty score showing how different they are compared to all other solutions evaluated so far.

Taming Heterogeneity and Distribution in sCPSIEEE/ACM 1st International Workshop on Software Engineering for Smart Cyber-Physical Systems (SEsCPS), 17 May 2015, Florence, Italy, INSPEC Accession Number:15378544, IEEE, 2015, Pages: 40-43, DOI: 10.1109/SEsCPS.2015.15

Authors: Brice Morin, Franck Fleurey, Olivier Barais 

Abstract: Smart Cyber Physical Systems (sCPS) are composed by a highly heterogeneous interconnection of platforms and devices offering a wide diversity of capabilities ranging from cloud server with virtually unlimited resources down to microcontrollers with only a few KB of RAM. This paper motivates the fact that no single software framework or software engineering approach is suited to span across this range, and proposes an approach which leverages the latest advances in model-driven engineering and models runtime in order to manage the heterogeneous and distributed nature of sCPS.

Development and testing of a wearable multisensor device enabling continuous monitoring, 2014 IEEE-EMBS International Conference on Biomedical and Health Informatics (BHI), 1-4 June 2014, Valencia, Spain, Page(s): 213 - 218, DOI: 10.1109/BHI.2014.6864342

Authors: Trine M. Seeberg-IEEE Member, Jon Vedum-IEEE Member, Mariann Sandsund, Hanne O. Austad, Anders E. Liverud, Astrid-Sofie B. Vardøy, Ingrid Svagård, Frode Strisland

Abstract: This paper reports on the development and testing of a wearable device intended as a component in an ambulatory system for health monitoring of physical rehabilitation patients. The device measures heart rate, skin temperature, activity level and posture on the user’s chest. The wearable device has been run through a set of verification tests and the accuracy has been validated in controlled environment on 12 healthy volunteers. A long term user pilot with 5 congestive heart failure patients and their nurses was performed to test the whole system. The conclusion from the performed tests is that the developed wearable multisensor monitoring device is reliable, accurate, easy to use and fit for the purpose.

Scapegoat: An Adaptive Monitoring Framework for Component-Based Systems, 2014 IEEE/IFIP Conference on Software Architecture (WICSA), 7-11 April 2014, Sydney, Australia, Australia, ISBN: 978-1-4799-3413-3, IEEE, Pages: 67-76, DOI: 10.1109/WICSA.2014.49

Authors: Inti Gonzalez-Herrera, Johann Bourcier, Erwan Daubert, Walter Rudametkin, Olivier Barais, Francois Fouquet, Jean-Marc Jezequel

Abstract: Modern component frameworks support continuous deployment and simultaneous execution of multiple software components on top of the same virtual machine. However, isolation between the various components is limited. A faulty version of any one of the software components can compromise the whole system by consuming all available resources. In this paper, we address the problem of efficiently identifying faulty software components running simultaneously in a single virtual machine. Current solutions that perform permanent and extensive monitoring to detect anomalies induce high overhead on the system, and can, by themselves, make the system unstable. In this paper we present an optimistic adaptive monitoring system to determine the faulty components of an application. Suspected components are finely instrumented for deeper analysis by the monitoring system, but only when required. Unsuspected components are left untouched and execute normally. Thus, we perform localized just-in-time monitoring that decreases the accumulated overhead of the monitoring system. We evaluate our approach against a state-of-the-art monitoring system and show that our technique correctly detects faulty components, while reducing overhead by an average of 80%.

Designing and evolving distributed architecture using kevoree, Proceedings of the 10th international ACM Sigsoft conference on Quality of software architectures (QoSA '14), Pages 147-148, ACM, New York, NY, USA ©2014, ISBN: 978-1-4503-2576-9, DOI: 10.1145/2602576.2611461

Authors: François Fouquet, Grégory Nain, Erwan Daubert, Johann Bourcier, Olivier Barais, Noël Plouzeau, Brice Morin

Abstract: Modern software applications are distributed and often operate in dynamic contexts, where requirements, assumptions about the environment, and usage profiles continuously change. These changes are difficult to predict and to anticipate at design time. The running software system should thus be able to react on its own, by dynamically adapting its behavior, in order to sustain a required quality of service. A key challenge is to provide the system with the necessary flexibility to perform self-adaptation, without compromising dependability. Models@Runtime is an emerging paradigm aiming at transferring traditional modeling activities (focusing on quality, verification, and so on) performed by humans, to the running system. In this trend, Kevoree provides a models@ runtime platform to design heterogeneous, distributed and adaptive applications based on the component based software engineering paradigm. At the end of this tutorial, applicants will be able to develop and assemble new components and communication channel to design complex self-adaptable distributed architectures by reusing existing piece of code.

Latest News

Final HEADS project results on the future computing continuum!

Jun 28

After 42 months of research on heterogeneous and distributed services for future computing continuum, HEADS project concluded in

Tellu participating at Vitalis 2017

May 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 2017

Mar 20

We are very glad to announce that Tellu AS has officially been selected as one of the top inn