Using Aspects for Enforcing Formal Architectural Invariants

Formal methods such as Z and Petri nets can be used to specify invariants that should hold during the execution of component-based applications such as those regarding changes in the architecture of the application and valid sequences of architecture reconfigurations. Integrating logic for checking and enforcing these invariants into the application's implementation is generally done by adding appropriate code to the functional application code. In this paper, we discuss several limitations of this approach that may ensue in a disconnection between the application implementation and its formal specification. We propose an approach for specifying and enforcing architectural constraints, which combines formal methods and Aspect-Oriented Programming. We use the Z notation for describing the architectural invariants of the application and Petri nets for modeling coordination protocols. At the implementation level, aspects intercept architecture reconfiguration events and check according to the formal specification and the coordination protocol whether a reconfiguration action can be performed.

[1]  Reiko Heckel,et al.  A Formal Approach to Service Specification and Matching based on Graph Transformation , 2004, WSFM.

[2]  Antonio Goncalves Enterprise Java Beans , 2010 .

[3]  Flávio Oquendo π-Method: a model-driven formal method for architecture-centric software engineering , 2006, SOEN.

[4]  Michel Riveill,et al.  Component Management in a Dynamic Architecture , 2004, The Journal of Supercomputing.

[5]  George R. Ribeiro-Justo,et al.  Specifying and verifying reconfigurable software architectures , 2000, 2000 Proceedings International Symposium on Software Engineering for Parallel and Distributed Systems.

[6]  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,.

[7]  Tadao Murata,et al.  Petri nets: Properties, analysis and applications , 1989, Proc. IEEE.

[8]  Maritta Heisel,et al.  Formal Specification of Safety-Critical Software with Z and Real-Time CSP , 1996, SAFECOMP.

[9]  Ratka Resanovica,et al.  Software Support for Teaching Petri Nets: P3 , 2003 .

[10]  Jim Woodcock,et al.  Using Z - specification, refinement, and proof , 1996, Prentice Hall international series in computer science.

[11]  Rémi Douence,et al.  Composition, reuse and interaction analysis of stateful aspects , 2004, AOSD '04.

[12]  Mark Saaltink,et al.  The Z/EVES Reference Manual (for Version 1.5) , 1997 .

[13]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[14]  C. Chambers,et al.  ArchJava: connecting software architecture to implementation , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[15]  M.J. Rodriguez-Fortiz,et al.  Using predicate temporal logic and coloured Petri nets to specifying integrity restrictions in the structural evolution of temporal active systems , 2000, Proceedings International Symposium on Principles of Software Evolution.

[16]  Ondrej Lhoták,et al.  Adding trace matching with free variables to AspectJ , 2005, OOPSLA '05.

[17]  Yi Deng,et al.  Formally analyzing software architectural specifications using SAM , 2004, J. Syst. Softw..

[18]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

[19]  Hong Yan,et al.  DiscoTect: a system for discovering architectures from running systems , 2004, Proceedings. 26th International Conference on Software Engineering.

[20]  Mohamed Jmaiel,et al.  Evaluation and Comparison of ADL Based Approaches for the Description of Dynamic of Software Architectures , 2005, ICEIS.

[21]  Lidia Fuentes,et al.  AO-ADL: An ADL for Describing Aspect-Oriented Architectures , 2007, EA@AOSD.

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

[23]  Bill Stoddart,et al.  An operational semantics for ZCCS , 1997, First IEEE International Conference on Formal Engineering Methods.

[24]  Chang Jun CORBA Component Model , 2003 .

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

[26]  Wolfgang Grieskamp,et al.  The |SZ Notation - Version 1.0 , 1997 .

[27]  Graeme Smith,et al.  A Semantic Integration of Object-Z and CSP for the Specification of Concurrent Systems , 1997, FME.

[28]  Gregor Kiczales,et al.  Aspect-oriented programming , 1996, CSUR.

[29]  Lidia Fuentes,et al.  Towards executable aspect-oriented UML models , 2007 .

[30]  G. H. Hilderink,et al.  Graphical modelling language for specifying concurrency based on CSP , 2003, IEE Proc. Softw..

[31]  Mira Mezini,et al.  Expressive Pointcuts for Increased Modularity , 2005, ECOOP.

[32]  Mohamed Jmaiel,et al.  Towards a Unified Graph-Based Framework for Dynamic Component-Based Architectures Description in Z , 2004, The IEEE/ACS International Conference on Pervasive Services.