Abstract. As embedded systems must constantly integrate new functionalities, their developement cycles must be based on high-level abstractions, making the software design more flexible. CBSE provides an approach to these new requirements. However, low-level services provided by operating systems are an integral part of embedded applications, furthermore deployed on resource-limited devices. Therefore, the expected benefits of CBSE must not impact on the constraints imposed by the targetted domain, such as memory footprint, energy consumption, and execution time. In this paper, we present the componentization of a legacy industry-established Real-Time Operating System, and how componentbased applications are built on top of it. We use the Think framework that allows to produce flexible systems while paying for flexibility only where desired. Performed experimentions show that the induced overhead is negligeable.

Component-Based Software Engineering (CBSE) does not yet fully address non-functional requirements of embedded systems. To reach this goal, we show how to extend a component model like FRACTAL with relevant abstractions such as threads, protection rings, or security domains. The FRACTAL Architecture Description Language (ADL) is extended by means of properties that tag components, bindings, and interfaces of the system architectural definition with execution schemes, dynamic reconfiguration strategies, protection and isolation patterns, or QoS features. Each extension captures a property-specific "system view" offering a sound basis to address some non-functional requirement. These extensions were experimented in the THINK framework, a C-based implementation of FRACTAL. Results show that THINK provides a generic and efficient approach to fully support these extensions thanks to a customizable toolchain.

As functionalities required by embedded systems increase, higher levels of abstraction become necessary to fulfill development exigences. At the same time, traditional physical and economical constraints such as size, memory usage and energy consumption subsist, making embedded systems development even more complex as it must face two contradictory requirements. In this paper, we expose how a component-based development framework is able to support these two conflicting demands. We follow a component-based approach to benefit from reusability and separation of concerns at design-time, producing flexible systems. We propose a set of flexibility-oriented properties allowing architects to generate, for a same architecture, a set of systems with different flexibility capabilities; these optimization techniques allow developers to pay for flexibility only where it is actually desired. Experiments conducted on several use-cases confirm the effectiveness of our approach.

The French Critical Zone research infrastructure, OZCAR-RI, gathers 20 observatories sampling various compartments of the critical zone, each having developed their own data management and distribution systems. A common information system (Theia/OZCAR IS) was built to make their in situ observation FAIR (findable, accessible, interoperable, reusable). The IS architecture was designed after consultation of the users, data producers and IT teams involved in data management. A common data model based on various metadata standards was defined to create information fluxes between observatories' ISs and the Theia/OZCAR IS. Controlled vocabularies were defined to develop a data discovery web portal offering a faceted search with various criteria, including variables names and categories that were harmonized in a thesaurus published on the web. This paper describes the IS architecture, the pivot data model and open-source solutions used to implement data discovery, and future steps to implement data downloading and interoperability services.

Dynamic reconfiguration features let embedded software systems evolve from original design and development time configurations in order to offer new functionalities or adapt themselves to new working contexts and requirements, among other goals. Component models provide an architectural pattern that eases development of software systems, as well as programming and execution of reconfiguration operations. However, binary-level reification of components and metadata needed for reconfiguration purposes may induce prohibitive performance loss. In this paper we define a reconfiguration infrastructure and propose strategies to minimize the impact of adding reconfiguration capabilities to a system in terms of memory occupation as a performance metric. We find that, by defining specific trade-offs between evolution capabilities and consumed memory space, it is possible to optimize the size of the reconfiguration infrastructure. Evaluation results illustrate this point and confirm the effectiveness of our approach.