Gilles Ardourel

Checking component composability

Component-Based Software Engineering (CBSE) is one of the approaches to master the development of large scale software. In this setting, the verification concern is still a challenge. The current work addresses the composability of components and their services. A component model (Kmelia) is introduced; an associated formalism, simple but expressive is introduced; it describes the services as extended LTSs and their structuring as components. The composability of components is defined on the basis of the composability of services. To ensure the correctness of component composition, we check that an assembly is possible via the checking of the composability of the linked services, and their behavioural compatibility. In order to mechanize our approach, the services and the components are translated into the Lotos formalism. Finally the Lotos CADP toolbox is used to perform experiments.

Composing components with shared services in the Kmelia model

The Kmelia abstract componentmodel is extended to allow the description of component compositions with multipart interactions leading to simultaneous communications between more than two services. Shared services are defined to explicitly control multipart interactions. Accordingly the communication actions of Kmelia are extended. The formal definitions of the Kmelia model, the composition of components via their services and their analysis are revisited to integrate the extension of the model. An example illustrates the need and the usage of shared services.

Static analysis of aspect interaction and composition in component models

Component based software engineering and aspect orientation are claimed to be two complementary approaches. While the former ensures the modularity and the reusability of software entities, the latter enables the modularity of crosscutting concerns that cannot be modularized as regular components. Nowadays, several approaches and frameworks are dedicated to integrate aspects into component models. However, when several aspects are woven, aspects may interact with each other which often results in undesirable behavior. The contribution of this paper is twofold. First, we show how aspectized component models can be formally modeled in UPPAAL model checker in order to detect negative interactions (a.k.a., interferences) among aspects. Second, we provide an extendible catalog of composition operators used for aspect composition. We illustrate our general approach with an airport Internet service example.

Defining component protocols with service composition: illustration with the Kmelia model

We address in this article the description and usage of component protocols viewed as specific services. In addition to inter-component service composition, our Kmelia component model supports vertical structuring mechanisms that allow service composition inside a component. The structuring mechanisms (namely state annotation and transition annotation) are then used to describe protocols which are considered here as component usage guides. These structuring mechanisms are integrated in the support language of our component model and are implemented in our COSTO toolbox. We show how protocol analysis is performed in order to detect some inconsistencies that may be introduced by the component designers.

Using Assertions to Enhance the Correctness of Kmelia Components and their Assemblies

The Kmelia component model is an abstract formal component model based on services. It is dedicated to the specification and development of correct components. This work enriches the Kmelia language to allow the description of data, expressions and assertions when specifying components and services. The objective is to enable the use of assertions in Kmelia in order to support expressive service descriptions, to support client/supplier contracts with pre/post-conditions, and to enhance formal analysis of component-based systems. Assertions are used to perform analysis of services, component assemblies and service compositions. Additionally we enable the definition of virtual contexts for required services and the corresponding observable state space for the components which provide the services. We illustrate the work with the verification of consistency properties involving data at component and assembly levels.

Adaptation for Hierarchical Components and Services

Software coordination and adaptation are tightly related to modular software entities and access points. These entities (components or services) may be complex, dissimilar (various models) and designed at different granularity levels. In order to allow interoperability we need rich interface descriptions including service hierarchisation, flexible declarations and precise specifications. In this article we present a Hierarchical Behavioural interface description language that enables the structuring of services, their encapsulation and it also facilitates the use of component interfaces. We also investigate in this work the adaptation for Hierarchical Behavioural IDL. We recall various adaptation problems and we introduce modelling techniques and some solutions within hierarchical context considering precision of the interfaces, their layering and flexibility.

JavaCompExt: Extracting Architectural Elements from Java Source Code

Abstract—Software architecture erosion is a general problem in legacy software. To fight this trend, component models and languages are designed to try to make explicit, and automatically enforceable, the architectural decisions in terms of components, interfaces, and allowed communication channels between component interfaces. To help maintainers work on existing object-oriented systems, we explore the possibility of extracting architectural elements (components, communications, services, ...) from the source code. We designed a tool based on some heuristics for extracting component information from Java source code.

Composable Controllers in Fractal: Implementation and Interference Analysis

Fractal component model provides controllers for adding extra-functional capabilities to component behaviors. However, controllers may interfere one with another and their composition is still a challenge. In this article, we extend Fractal with a support for composing controllers with reusable operators. Then, we discuss how to formally model and analyze, in Uppaal, Fractal systems with several controllers. This enables us to detect when controllers interfere and to check whether their composition is interference-free.

Component service promotion: contracts, mechanisms and safety

Composition is a core concept of component and service-based models. In hierarchical component composition, promotion is used to make services available at a higher level of the hierarchy without breaking encapsulation. In this article we will study different kinds of promotion of services equipped with contracts, their usefulness, as well as their safety by considering appropriate proof obligations. We introduce several explicit assertion constructs in order to reduce the proof effort. We study the impact of encapsulation and rich state description on these promotions. We illustrate the approach (specification and verification) with the Kmelia component language.

Using event-b to verify the Kmelia components and their assemblies

Component-based software engineering is a practical approach to address the issue of building large software by combining existing and new components. However, building reliable software systems from components requires to verify the consistency of components and the correctness of their assemblies.