Frédéric Loiret

Programming sensor networks using REMORA component model

The success of high-level programming models in Wireless Sensor Networks (WSNs) is heavily dependent on factors such as ease of programming, code well-structuring, degree of code reusability, and required software development effort. Component-based programming has been recognized as an effective approach to meet such requirements. Most of componentization efforts in WSNs were ineffective due to various reasons, such as high resource demand or limited scope of use. In this paper, we present Remora, a new approach to practical and efficient component-based programming in WSNs. Remora offers a well-structured programming paradigm that fits very well with resource limitations of embedded systems, including WSNs. Furthermore, the special attention to event handling in Remora makes our proposal more practical for WSN applications, which are inherently event-driven. More importantly, the mutualism between Remora and underlying system software promises a new direction towards separation of concerns in WSNs. Our evaluation results show that a well-configured Remora application has an acceptable memory overhead and a negligible CPU cost.

Optimizing sensor network reprogramming via in situ reconfigurable components

Wireless reprogramming of sensor nodes is a critical requirement in long-lived wireless sensor networks (WSNs) addressing several concerns, such as fixing bugs, upgrading the operating system and applications, and adapting applications behavior according to the physical environment. In such resource-poor platforms, the ability to efficiently delimit and reconfigure the necessary portion of sensor software—instead of updating the full binary image—is of vital importance. However, most existing approaches in this field have not been adopted widely to date due to the extensive use of WSN resources or lack of generality. In this article, we therefore consider WSN programming models and runtime reconfiguration models as two interrelated factors and we present an integrated approach for addressing efficient reprogramming in WSNs. The middleware solution we propose, <scp<RemoWare</scp<, is characterized by mitigating the cost of post-deployment software updates on sensor nodes via the notion of in situ reconfigurability and providing a component-based programming abstraction in order to facilitate the development of dynamic WSN applications. Our evaluation results show that <scp<RemoWare</scp< imposes a very low energy overhead in code distribution and component reconfiguration and consumes approximately 6% of the total code memory on a <scp<TelosB</scp< sensor platform.

On the modeling and generation of service-oriented tool chains

Abstract Tool chains have grown from ad-hoc solutions to complex software systems, which often have a service-oriented architecture. With service-oriented tool integration, development tools are made available as services, which can be orchestrated to form tool chains. Due to the increasing sophistication and size of tool chains, there is a need for a systematic development approach for service-oriented tool chains. We propose a domain-specific modeling language (DSML) that allows us to describe the tool chain on an appropriate level of abstraction. We present how this language supports three activities when developing service-oriented tool chains: communication, design and realization. A generative approach supports the realization of the tool chain using the service component architecture. We present experiences from an industrial case study, which applies the DSML to support the creation of a service-oriented tool chain. We evaluate the approach both qualitatively and quantitatively by comparing it with a traditional development approach.

Flex-eWare: a flexible model driven solution for designing and implementing embedded distributed systems

The complexity of modern embedded systems increases as they incorporate new concerns such as distribution and mobility. These new features need to be considered as early as possible in the software development life cycle. Model driven engineering promotes an intensive use of models and is now widely seen as a solution to master the development of complex systems such as embedded ones. Component‐based software engineering is another major trend that gains acceptance in the embedded world because of its properties such as reuse, modularity, and flexibility.

A Generic Component-Based Approach for Programming, Composing and Tuning Sensor Software

Wireless sensor networks (WSNs) are being extensively deployed today in various monitoring and control applications by enabling rapid deployments at low cost and with high flexibility. However, high-level software development is still one of the major challenges to wide-spread WSN adoption. The success of high-level programming approaches in WSNs is heavily dependent on factors such as ease of programming, code well-structuring, degree of code reusability, required software development effort and the ability to tune the sensor software for a particular application. Component-based programming has been recognized as an effective approach to satisfy such requirements. However, most of the componentization efforts in WSNs were ineffective due to various reasons, such as high resource demand or limited scope of use. In this article, we present Remora, a novel component-based approach to overcome the hurdles of WSN software implementation and configuration. Remora offers a well-structured programming paradigm that fits very well with resource limitations of embedded systems, including WSNs. Furthermore, the special attention to event handling in Remora makes our proposal more practical for embedded applications, which are inherently event-driven. More importantly, the mutualism between Remora and underlying system software promises a new direction towards separation of concerns in WSNs. This feature also offers a practical way to develop sensor middleware services which should be generic and developed close to the operating system. Additionally, it allows the customization of sensor software—deploying only application-required system-level services on nodes, instead of installing a fixed large system software image for any application. Our evaluation results show that the deployed Remora applications have an acceptable memory overhead and a negligible CPU cost compared with the state-of-the-art development models.

A three-tier approach for composition of real-time embedded software stacks

Many component models and frameworks have been proposed to abstract and capture concerns from Real-Time and Embedded application domains, based on high-level component-based approaches. However, these approaches tend to propose their own fixed-set abstractions and ad-hoc runtime platforms, whereas the current trend emphasizes more flexible solutions, as embedded systems must constantly integrate new functionalities, while preserving performance. In this paper, we present a two-fold contribution addressing this statement. First, we propose to express these concerns in a decoupled way from the commonly accepted structural abstractions inherent to CBSE, and provide a framework to implement them in open and extensible runtime containers. Second, we propose a three-tier approach to composition where application, containers and the underlying operating system are designed using components. Supporting a homogeneous design space allows applying optimization techniques at these three abstraction layers showing that our approach does not impact on performance. In this paper, we focus our evaluation on concerns specific to the field of real-time audio and music applications.

Model-Based service discovery and orchestration for OSLC services in tool chains

Globally distributed development of complex systems relies on the use of sophisticated development tools but today the tools provide only limited possibilities for integration into seamless tool chains. If development tools could be integrated, development data could be exchanged and tracing across remotely located tools would be possible and would increase the efficiency of globally distributed development. We use a domain specific modeling language to describe tool chains as models on a high level of abstraction. We use model-driven technology to synthesize the implementation of a service-oriented wrapper for each development tool based on OSLC (Open Services for Lifecyle Collaboration) and the orchestration of the services exposed by development tools. The wrapper exposes both tool data and functionality as web services, enabling platform independent tool integration. The orchestration allows us to discover remote tools via their service wrapper, integrate them and check the correctness of the orchestration.

Software engineering of component-based systems-of-systems: a reference framework

Systems-of-Systems (SoS) are complex infrastructures, which are characterized by a wide diversity of technologies and requirements imposed by the domain(s) they target. In this context, the software engineering community has been focusing on assisting the developers by providing them domain-specific languages, component-based software engineering frameworks and tools to leverage on the design and the development of such systems. However, the adoption of such approaches often prevents developers from combining several domains, which is a strong requirement in the context of SoS. Furthermore, only little attention has been paid to the definition of a modular toolset and an extensible runtime infrastructure for deploying and executing SoS. In this paper, we therefore propose a reference framework to leverage on the software engineering of SoS. Our reference framework has been validated on the development of two platforms, namely Hulotte and FraSCAti, to demonstrate that the resulting complexity is isolated in the core toolset, while the development of domain-specific extensions is leveraged and simplified by clearly identified abstractions.

Integration of Heterogeneous Context Resources in Ubiquitous Environments

Ubiquitous environments provide families of context-aware applications that are capable of exploiting the user mobility as well as the device variability. Typically, these applications retrieve context information from local and remote providers and react accordingly to the detected variations. However, this must be done by considering the heterogeneity of devices and protocols found in ubiquitous environments. Unfortunately, although the context integration represents a keystone of context-aware systems, existing approaches in the literature fail to integrate the diversity of context sources in a standard and flexible way. Therefore, in this paper, we overcome this challenge by introducing resource-oriented bindings into the SCA (Service Component Architecture) model. This new kind of bindings follows the REpresentational State Transfer (REST) principles and leverages the provision of context as RESTful resources. A smart home scenario that highlights challenges in terms of integration in ubiquitous environments motivates the use of our approach.

Component-Oriented Development for Real-Time Java

The Real-Time Specification for Java (RTSJ) offers developers an attractive platform for development of software that is composed of variously stringent real-time and non real-time tasks. However, the RTSJ introduces a programming model involving several non-intuitive rules and restrictions which make systems modeling and development a complex and error-prone task. In this chapter we introduce an advanced software engineering technology that allows developers to address these challenges – component-oriented development. In the first part, we present the general concepts and identify the key benefits of this technology. We further show one of the possible approaches on how to embrace this technology when mitigating the complexities of RTSJ development – the Hulotte framework. The framework provides a continuum between the component-oriented design and implementation process of RTSJ systems. The RTSJ concepts are treated as first-class entities which enables the modeling and automatized preparation of their implementation by employing code-generation techniques. We conclude this chapter with an extensive case study comparing object-oriented and component-oriented implementation of the Collision Detector Benchmark. Our empirical evaluation shows that the performance overhead of the framework is minimal in comparison to manually written object-oriented applications without imposing any restrictions on the programming style.