ArchLog: Formal approaches for software architectures: component-based and service-oriented computing
The ArchLog group carries out research on formal approaches for component-based and service-oriented architectures. It was created on February 2005 when Prof. Flavio Oquendo moved from the University of Savoie at Annecy to the University of South Brittany at Vannes.
Key Areas
- The Architecture Description Language: π-ADL
- The Architecture Analysis Language: π-AAL
- The Architecture Refinement Language: π-ARL
- Formal development techniques
- π-calculus
- Dynamic software architectures
- Ambient intelligence
- Sensor-actuator networks
- Mobile agent systems
- Human-computer interfaces for monitoring systems
- Grid computing systems
- Enterprise application integration systems
- Software systems targeting J2EE platforms
Objectives
One of the most challenging tasks in software engineering is to assure continuous correctness, especially as software systems are increasingly used in highly dynamic and often distributed, mobile and context-aware environments such as in ambient intelligence applications. In order to reach this grand objective, the following open issues need to be addressed:
- to support the formal specification of software systems whose architecture can change, on-the-fly, at run-time;
- to support their automated analysis with respect to functional as well non-functional properties;
- to support their property-preserving transformations and application synthesis, by stepwise refinement from abstract to concrete specifications and full code generation, as well as their subsequent evolution;
- to support compliance with respect to application requirements on-the-fly, i.e. if requirements change, enable the software system to safely change to continuously cope with requirements.
In order to address these issues, the ArchLog group defines and develops languages, processes, and tools to support the continuous specification, analysis, refinement, and compliant evolution of software systems, in particular ambient intelligence software systems. Indeed, a holistic formal engineering approach is needed that does not concentrate on one-shot software development but rather on continuous engineering and on-the-fly adaptation of software systems. Our work for defining and developing a holistic solution relies on a formal architecture-centric model-driven engineering approach.
Why formal?
Correctness of software systems can be improved by formalising different products and processes in the life-cycle. Among the reasons to apply formal foundations to our languages and tools are: to improve documentation and understanding of specifications, to enable rigorous analysis of the system properties, to be as certain as possible that the transformations and implementation are property-preserving and error-free, to improve rigour and quality of the whole development process, and to provide a firm foundation during the adaptation and evolution process.
Why architecture-centric?
Software architecture has emerged as an important subdiscipline of software engineering. A key aspect of the design of any software system is its architecture, i.e. the fundamental organisation of the system embodied in its components, their relationships to each other, and to the environment, and the principles guiding its design and evolution. Software architecture forms the backbone for building successful software-intensive systems. Architecture descriptions provide thereby the conceptual abstraction for modelling complex software systems during development and then during deployment and on-the-fly adaptation and evolution.
Why model-driven engineering?
All forms of engineering rely on models to design real-world systems. Models are used in many ways: to understand specific system aspects, predict system qualities, reason about impact of changes, and communicate major system features to stakeholders. In a model-driven approach, i.e. the system models have sufficient detail to enable the generation of a full system implementation from the models themselves. Indeed, “the model is the code”, i.e. the focus is on modelling and code is mechanically generated from models. In an architecture-centric model-driven engineering approach, models are component-based architectural (run-time) models. They support model analysis, property-preserving transformations, and application synthesis.
More precisely, our objective is to define and develop an integrated set of formal architecture-centric languages, processes, and tools for the model-driven engineering and continuous evolution of software systems based on the π-calculus and related theories. It comprises of:
(a) formal architecture description, analysis, and refinement languages for specifying the architecture of evolvable software systems, verifying their properties and expressing their refinements;
(b) tools to support architecture description, analysis, and refinement as well as code generation;
(c) enactable processes for supporting model-driven engineering and continuous evolution relying on a persistent run-time virtual machine for process enactment.
Detailed description of ArchLog research activities can be found Here
