Dynamic software architectures: formal specification and verification with CSP

Compared to the traditional software architecture, Dynamic Software Architectures (DSAs) should be able to describe the changes of the system and to effect modifications during system execution, especially for dynamic evolution. To reflect the changes during system execution, we present a formalism for describing architecture structure and interaction behavior, and we also specify four evolution rules for software architecture. Our work expands the idea in three directions. The first is to formalize the architecture structure and interaction behavior including components, connectors and an architectural reference model. The second direction is that we formalize four dynamic evolution rules which DSAs should support, that is, addition, removal, replacement and reconfiguration. Another direction is that we verify software architecture consistency and integrity after dynamic evolution. We use a client/server application as a running example throughout the paper to demonstrate our approach. Our work provides a precise formal specification for software architecture and a rigorous verification for dynamic evolution.

[1]  Jennifer Pérez,et al.  PRISMA: towards quality, aspect oriented and dynamic software architectures , 2003, Third International Conference on Quality Software, 2003. Proceedings..

[2]  Xu Hongzhen,et al.  Specification and verification of dynamic evolution of software architectures , 2010, J. Syst. Archit..

[3]  C. J. Koomen.  The Design of Communicating Systems , 1991 .

[4]  David Garlan,et al.  Specifying and Analyzing Dynamic Software Architectures , 1998, FASE.

[5]  Markus Endler,et al.  Programming generic dynamic reconfigurations for distributed applications , 1992, CDS.

[6]  David C. Luckham,et al.  Rapide: A language and toolset for simulation of distributed systems by partial orderings of events , 1997, Partial Order Methods in Verification.

[7]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

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

[9]  David Garlan,et al.  Acme: architectural description of component-based systems , 2000 .

[10]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[11]  Robin Milner,et al.  The Polyadic π-Calculus: a Tutorial , 1993 .

[12]  David Garlan,et al.  A Formal Approach to Software Architectures , 1992, IFIP Congress.

[13]  Richard Torkar,et al.  Dynamic Software Architectures , 2002 .

[14]  Daniel Le Métayer.  Describing Software Architecture Styles Using Graph Grammars , 1998, IEEE Trans. Software Eng..

[15]  Nazareno Aguirre,et al.  A temporal logic approach to the specification of reconfigurable component-based systems , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[16]  Jian Lü,et al.  Technical framework for Internetware: An architecture centric approach , 2008, Science in China Series F: Information Sciences.

[17]  Feng Chen,et al.  ABC/ADL: An ADL Supporting Component Composition , 2002, ICFEM.

[18]  Mohamed Jmaiel,et al.  Using UML2.0 and GG for describing the dynamic of software architectures , 2005, Third International Conference on Information Technology and Applications (ICITA'05).

[19]  Hong Mei,et al.  Automated adaptations to dynamic software architectures by using autonomous agents , 2004, Eng. Appl. Artif. Intell..

[20]  Xin Peng,et al.  A Unified Formal Model for Supporting Aspect-Oriented Dynamic Software Architecture , 2007, 2007 International Conference on Convergence Information Technology (ICCIT 2007).

[21]  Flávio Oquendo.  Dynamic Software Architectures: Formally Modelling Structure and Behaviour with Pi-ADL , 2008, 2008 The Third International Conference on Software Engineering Advances.

[22]  Michel Wermelinger.  Towards a chemical model for software architecture reconfiguration , 1998, IEE Proc. Softw..

[23]  Ugo Montanari,et al.  Graph grammars and constraint solving for software architecture styles , 1998, ISAW '98.

[24]  Xin Peng,et al.  Implementing Self-Adaptive Software Architecture by Reflective Component Model and Dynamic AOP: A Case Study , 2010, 2010 10th International Conference on Quality Software.