A formal approach for managing component-based architecture evolution

Software architectures are subject to several types of change during the software lifecycle (e.g. adding requirements, correcting bugs, enhancing performance). The variety of these changes makes architecture evolution management complex because all architecture descriptions must remain consistent after change. To do so, whatever part of the architectural description they affect, the effects of change have to be propagated to the other parts. The goal of this paper is to provide support for evolving component-based architectures at multiple abstraction levels. Architecture descriptions follow an architectural model named Dedal, the three description levels of which correspond to the three main development steps - specification, implementation and deployment. This paper formalizes an evolution management model that generates evolution plans according to a given architecture change request, thus preserving consistency of architecture descriptions and coherence between them. The approach is implemented as an Eclipse-based tool and validated with three evolution scenarios of a Home Automation Software example. The paper presents a formal approach for managing component-based architecture evolution at multiple abstraction levels.The approach covers the full component-based software development process thanks to the Dedal architectural model.It enables software verification and validation through the generation of B formal specifications from diagrammatic models.It generates reliable evolution plans that prevent architecture inconsistencies.The approach is implemented and experimented on three different evolution scenarios.

[1]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[2]  Dominique Cansell,et al.  Incremental Proof of the Producer/Consumer Property for the PCI Protocol , 2002, ZB.

[3]  Régine Laleau,et al.  Taking into Account Functional Models in the Validation of IS Security Policies , 2011, CAiSE Workshops.

[4]  Lei Zhang,et al.  A three-level component model in component based software development , 2012, GPCE '12.

[5]  Michael J. Butler,et al.  ProB: an automated analysis toolset for the B method , 2008, International Journal on Software Tools for Technology Transfer.

[6]  Bradley R. Schmerl,et al.  Evolution styles: foundations and models for software architecture evolution , 2012, Software & Systems Modeling.

[7]  Alcino Cunha,et al.  Model repair and transformation with Echo , 2013, 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[8]  Flávio Oquendo,et al.  ArchWare: Architecting Evolvable Software , 2004, EWSA.

[9]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is So Hard , 1995, IEEE Softw..

[10]  Petr Hnetynka,et al.  Automated resolution of connector architectures using constraint solving (ARCAS method) , 2014, Software & Systems Modeling.

[11]  Christelle Urtado,et al.  Architecture-Centric Component-Based Development Needs a Three-Level ADL , 2010, ECSA.

[12]  Mourad Oussalah,et al.  Updating Software Architectures : A Style-Based Approach , 2006, Software Engineering Research and Practice.

[13]  Marianne Huchard,et al.  An evolution management model for multi-level component-based software architectures , 2015, SEKE.

[14]  J. Michael Spivey,et al.  The Z notation - a reference manual , 1992, Prentice Hall International Series in Computer Science.

[15]  Richard N. Taylor,et al.  A Component- and Message-Based Architectural Style for GUI Software , 1995, 1995 17th International Conference on Software Engineering.

[16]  Hans van Vliet,et al.  Software engineering - principles and practice , 1993 .

[17]  Richard N. Taylor,et al.  Software architecture: foundations, theory, and practice , 2009, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[18]  Richard N. Taylor,et al.  A language and environment for architecture-based software development and evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[19]  Klaus Marius Hansen,et al.  Modeling and analyzing architectural change with alloy , 2010, SAC '10.

[20]  Cliff B. Jones,et al.  Systematic software development using VDM , 1986, Prentice Hall International Series in Computer Science.

[21]  John Derrick,et al.  Z2SAL: a translation-based model checker for Z , 2009, Formal Aspects of Computing.

[22]  Mourad Oussalah,et al.  Evolution Shelf: Reusing Evolution Expertise within Component-Based Software Architectures , 2008, 2008 32nd Annual IEEE International Computer Software and Applications Conference.

[23]  Derek Rayside,et al.  Extending Alloy with Partial Instances , 2012, ABZ.

[24]  Gordon S. Blair,et al.  A component model for building systems software , 2004, IASTED Conf. on Software Engineering and Applications.

[25]  Claude Marché,et al.  The BWare Project: Building a Proof Platform for the Automated Verification of B Proof Obligations , 2014, ABZ.

[26]  Daniel Jackson,et al.  Software Abstractions - Logic, Language, and Analysis , 2006 .

[27]  Klaus Marius Hansen,et al.  Modeling architectural change: Architectural scripting and its applications to reconfiguration , 2009, 2009 Joint Working IEEE/IFIP Conference on Software Architecture & European Conference on Software Architecture.

[28]  Paul Benoit,et al.  Météor: A Successful Application of B in a Large Project , 1999, World Congress on Formal Methods.

[29]  Pierre Castéran,et al.  Interactive Theorem Proving and Program Development , 2004, Texts in Theoretical Computer Science An EATCS Series.

[30]  Marianne Huchard,et al.  Formal Rules for Reliable Component-Based Architecture Evolution , 2014, FACS.

[31]  Séverine Sentilles,et al.  A Classification Framework for Software Component Models , 2011, IEEE Transactions on Software Engineering.

[32]  Douglas C. Schmidt,et al.  Guest Editor's Introduction: Model-Driven Engineering , 2006, Computer.

[33]  Flávio Oquendo.  Formally refining software architectures with π-ARL: a case study , 2004, SOEN.

[34]  Dominique Cansell,et al.  Foundations of the B Method , 2003, Comput. Artif. Intell..

[35]  Marianne Huchard,et al.  Towards Automating the Coherence Verification of Multi-Level Architecture Descriptions , 2014, ICSEA 2014.

[36]  Craig A. Knoblock,et al.  PDDL-the planning domain definition language , 1998 .

[37]  Jeff Magee,et al.  Dynamic structure in software architectures , 1996, SIGSOFT '96.

[38]  David Garlan,et al.  Automated planning for software architecture evolution , 2013, 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[39]  Dharini Balasubramaniam,et al.  Controlling software architecture erosion: A survey , 2012, J. Syst. Softw..

[40]  Michael Leuschel,et al.  Directed Model Checking for B: An Evaluation and New Techniques , 2010, SBMF.

[41]  Graeme Smith,et al.  Model Checking Z Specifications Using SAL , 2005, ZB.

[42]  Alejandro Sanchez,et al.  Bigraphical Modelling of Architectural Patterns , 2011, FACS.

[43]  David Garlan,et al.  Acme: an architecture description interchange language , 2010, CASCON.

[44]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[45]  Flávio Oquendo.  π-ARL: an architecture refinement language for formally modelling the stepwise refinement of software architectures , 2004, SOEN.

[46]  Flávio Oquendo.  π-ADL: an Architecture Description Language based on the higher-order typed π-calculus for specifying dynamic and mobile software architectures , 2004, SOEN.

[47]  Marianne Huchard,et al.  Fostering component reuse: automating the coherence verification of multi-level architecture descriptions , 2014, ICSEA 2014.

[48]  Emil Axelsson,et al.  Combining Deep and Shallow Embedding for EDSL , 2012, Trends in Functional Programming.

[49]  Yves Bertot,et al.  Interactive Theorem Proving and Program Development: Coq'Art The Calculus of Inductive Constructions , 2010 .

[50]  Nuno Oliveira,et al.  A perspective on architectural re-engineering , 2015, Sci. Comput. Program..

[51]  Ulf Norell,et al.  Dependently typed programming in Agda , 2009, TLDI '09.

[52]  Yashar Ganjali,et al.  Optimum Multi-Dimensional Interval Routing Schemes on Networks with Dynamic Cost Links , 2003, Comput. Artif. Intell..

[53]  Emina Torlak,et al.  Kodkod: A Relational Model Finder , 2007, TACAS.

[54]  Ivica Crnkovic,et al.  A systematic review of software architecture evolution research , 2012, Inf. Softw. Technol..

[55]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is Still So Hard , 2009, IEEE Software.

[56]  Serge Demeyer,et al.  Software Evolution , 2010 .

[57]  Jean-Raymond Abrial,et al.  The B-book - assigning programs to meanings , 1996 .

[58]  Thaís Vasconcelos Batista,et al.  Mapping ADL Specifications to an Efficient and Reconfigurable Runtime Component Platform , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).