Section: Scientific Foundations
Aspect-Oriented Design of Dynamic Component Assemblies
The behaviour of a complex application in an open environment is difficult to specify and to implement because it has to evolve in accordance with the context. Changes can occur in an asynchronous manner and the behaviour has to be adapted without human actions and without stopping the application. A language to specify an assembly of components has to capture these dynamic aspects. A platform which supports the assembly at run-time also has to be able to respond to the needed changes. In this part of the project we plan to investigate three directions.
The first one deals with the study of separation of concerns from the first steps of analysis to the implementation. The goal is to trace the evolution of different concerns in these various stages. The second goal is related to the dynamic features of the Architecture Description Languages (ADL) [75] , [88] . The last goal focuses on Aspect-Oriented Programming [69] [76] [95] in which one can capture a specific concern of an application.
Finally, this project part enhances specifications of component assemblies with the goal of designing adaptable applications. We introduce integration contracts for specifying the impact of components on the application and its context [62] , [66] . Our approach is based on AOP to specify connection and integration schemas.
Early Aspects
Business applications are faced with two main challenges. On one hand, they are mostly developed using an iterative process where business functionalities are added to the core application as the project requirements evolve [55] . On the other hand, the non-functional requirements (in terms of security, remote communication and transaction, data persistence, etc.) are also high and need to be incorporated as seamlessly as possible. Both the component-based and the aspect-oriented approaches separatively provide directions for these challenges. However there is no integrated software processes that takes both into account. The goal of this work is thus to propose such a process and some tools to support it. This process starts at the early stages of analysis and the tools provide features to trace the evolution from user requirements until deployment and run-time. This work is done in the context of Dolores Diaz's PhD thesis [68] .
Aspects at Design-time
Software architects and designers use reasoning frameworks to iteratively integrate functional and non-functional concerns into their projects, and to adapt them to unforseen functional or non-functional requirements. To assist them, analysis methods support modelling and verification tools from functional to technical architecture. Their main advantages are to model large-scaled distributed systems that require interoperability between system parts and the separation of concerns between business functionality and communication mechanisms.
However, no standard and universal definition of software architecture has been accepted by all the community [56] , [57] , [64] , [88] . Various points of view on different studies yield several approaches. These approaches focus on only one or two concerns such as component interface specification, behavioural analysis or software reconfiguration. So we argue that, in order to increase the benefits of software architecture approaches, one may need to use an architecture centric approach with a global reasoning: from software architecture design to software architecture management to software architecture building, deployment and refinement. However, these different concerns of a software architecture definition must be kept consistent.
Our first goal is to propose enhancements of a component model for specifying dynamic evolution of a software architecture. It concerns three points of view: structural, functional and behavioural points of view [91] , [61] , [59] . We use the Model Driven Architecture approach with Context Independent Model and Context Specific Model. Our second goal is to introduce non-functional aspects and connections between components and containers in languages for software architectures. We extend contracts between components to contracts between components and non-functional components [60] .
Aspects at Run-time
In distributed environments, applications run in an open context. They use networks and their associated services for which quality of service is not always guaranteed and may change quickly. In these environments, several concerns must be considered, including fault tolerance, data consistency, remote version update, runtime maintenance, dynamic lookup, scalability, lack of rate. Addressing these issues may require dynamic and fast reconfiguration of distributed applications [90] , [100] , [101] .
We have defined the Java Aspect Components (JAC) framework for building aspect-oriented distributed applications in Java [94] , [96] , [97] . Unlike other languages such as AspectJ, JAC allows dynamic weaving of aspects (aspects can be woven or unwoven at run-time) and proposes a modular solution to specify the composition of aspects. We defined an aspect-oriented programming model and the architectural details of the framework implementation. The framework enables extension of application semantics for handling well-separated concerns. This is achieved with a software entity called an aspect component (AC). ACs provide distributed pointcuts, dynamic wrappers and metamodel annotations. Distributed pointcuts are a key feature of our framework. They enable the definition of crosscutting structures that do not need to be located on a single host. ACs are dynamic: They can be added, removed, and controlled at runtime. This enables our framework to be used in highly dynamic environments where software adaptation is needed.
