Location of Repository

Compositional verification of model-level refactorings based on graph transformations

By Dénes András Bisztray


With the success of model-driven development as well as component-based and\ud service-oriented systems, models of software architecture are key artifacts in the development\ud process. To adapt to changing requirements and improve internal software\ud quality such models have to evolve while preserving aspects of their behaviour. These\ud behaviour preserving developments are known as refactorings.\ud The verification of behaviour preservation requires formal semantics, which can\ud be defined by model transformation, e.g., using process algebras as semantic domain\ud for architectural models. Denotational semantics of programming languages are by\ud definition compositional. In order to enjoy a similar property in the case of model\ud transformations, every component of the source model should be distinguishable in the\ud target model and the mapping compatible with syntactic and semantic composition.\ud To avoid the costly verification of refactoring steps on large systems and create\ud refactoring patterns we present a general method based on compositional typed graph\ud transformations. This method allows us to extract a (usually much smaller) rule\ud from the transformation performed, verify this rule instead and use it as a refactoring\ud pattern in other scenarios.\ud The main result of the thesis shows that the verification of rules is indeed sufficient\ud to guarantee the desired semantic relation between source and target models. A formal\ud definition of compositionality for mappings from software models represented as\ud typed graphs to semantic domains is proposed. In order to guarantee compositionality,\ud a syntactic criterion has been established for the implementation of the mappings\ud by typed graph transformations with negative application conditions. We apply the\ud approach to the refactoring of architectural models based on UML component, structure,\ud and activity diagrams with CSP as semantic domain

Publisher: University of Leicester
Year: 2010
OAI identifier: oai:lra.le.ac.uk:2381/7882

Suggested articles



  1. (2005). (QVT) Final Adopted Specification.
  2. (2005). A brief history of process algebra.
  3. (1996). A Compositional Approach to Performance Modelling.
  4. (1997). A Formal Approach to Software Architecture.
  5. (2008). A framework for the verification of infinite-state graph transformation systems.
  6. (1998). A fully abstract model for graphintepreted temporal logic.
  7. (2003). A hierarchical program representation for refactoring.
  8. (2008). A landscape of bidirectional model transformations.
  9. (2003). A logic for analysing abstractions of graph transformation systems.
  10. (2008). A modal-logic based graph abstraction.
  11. (2005). A taxonomy of model transformations.
  12. (2002). A toolkit for manipulating uml models.
  13. (1997). Algebraic approaches to graph transformation - part i: Basic concepts and double pushout approach.
  14. (1988). Algebraic theory of processes.
  15. (2002). An analyzable annotation language.
  16. (2006). An approach to invariantbased program refactoring.
  17. (2004). An introduction to Model Driven Architecture. IBM,
  18. (2007). Analysing refactoring dependencies using graph transformation. Software and Systems Modeling (SoSyM),
  19. (2004). Applying refactoring techniques to uml/ocl models.
  20. (2002). Approximating the behaviour of graph transformation systems.
  21. (2007). Attributed Graph Grammar System Environment.
  22. (1996). Autofocus: A tool for distributed systems specification.
  23. (1993). Automated assistance for program restructuring.
  24. (2004). Automated formal verification of visual modelign languages.
  25. (1991). Basic Category Theory for Computer Scientists. Foundations of Computing.
  26. (2008). Behavior preservation in model refactoring using dpo transformations with borrowed contexts.
  27. (2007). Bidirectional model transformations in qvt: Semantic issues and open questions.
  28. (2007). Bisimulation verification for the dpo approach with borrowed contexts.
  29. (2004). Canonical graph shapes. In
  30. (2002). Challenges of refactoring c programs.
  31. (2003). CheckVML: a tool for model checking visual modeling languages.
  32. (2006). Cloning and expanding graph transformation rules for refactoring.
  33. (2008). Combining quality assurance and model transformations in business-driven development.
  34. (1985). Communicating Sequential Processes.
  35. (1998). Composite refactorings for java programs.
  36. (1998). Compositional verification of reactive systems specified by graph transformation.
  37. (1998). Concatenable graph processes: relating processes and derivation traces.
  38. (2002). Confluence of typed attributed graph transformation systems.
  39. (2003). Coordinated distributed diagram transformation for software evolution.
  40. (2006). Counterexample-guided abstraction refinement for the analysis of graph transformation systems.
  41. (2006). Deriving bisimulation congruences in the dpo approach to graph rewriting with borrowed contexts.
  42. (1994). Design Patterns: Elements of Reusable Object-Oriented Software.
  43. (2007). Dirk Mu¨ller 0002, and Tom Mens. Specifying domainspecific refactorings for andromda based on graph transformation.
  44. (2003). dos Santos. Verification of distributed object-based systems.
  45. (2005). dos Santos. Verifying faulttolerant distributed systems using object-based graph grammars.
  46. (1996). Dynamic structure in software architectures.
  47. (2007). Eclipse Graphical Modeling Framework.
  48. (2009). Eclipse Integrated Development Environment.
  49. (2007). Eclipse Modeling Framework.
  50. (1996). Elements of basic category theory.
  51. (2008). Embedding and confluence of graph transformations with negative application conditions.
  52. (2006). Emf model refactoring based on graph transformation concepts.
  53. (2001). Evolving object-oriented designs with refactorings.
  54. (2008). Explicit state model checking for graph grammars. In
  55. (2007). Exploring a method to detect behaviourpreserving evolution using graph transformation. In
  56. (2004). Extending graph rewriting for refactoring.
  57. (2007). Formal verification of objectoriented graph grammars specifications.
  58. (2002). Formalising behaviour preserving program transformations.
  59. (2002). Free Online Dictionary of Computing. Unified Modelling Language,
  60. (2006). Fundamentals of Algebraic Graph Transformation (Monographs in Theoretical Computer Science). An EATCS Series.
  61. (2005). Gabriele Taentzer, Da´niel Varro´, and Szilvia Varro´-Gyapay. Termination criteria for model transformation.
  62. (2005). Graph grammar verification through abstraction. In Graph transforamtion and process algebras for Bibliography 166 modeling distributed and mobile systems, volume 04241 of Dagstuhl Seminar,
  63. (1996). Graph processes. Fundamenta Informaticae,
  64. (2005). Graph transformation with variables.
  65. (2008). Hartmut Ehrig De´nes Bisztray, Reiko Heckel. Verification of architectural refactoring rules.
  66. (2008). Hartmut Ehrig, and Fernando Orejas. Efficient conflict detection in graph transformation systems by essential critical pairs.
  67. (2002). How to Win the Culture War.
  68. (1993). Hypergraph rewriting: critical pairs and undecidability of confluence.
  69. (2000). Integration of Graph Transformation and Temporal Logic for the Specification of Distributed Systems.
  70. (1995). Introduction to the special issue on software architecture.
  71. (1996). Laws of software evolution revisited.
  72. (1925). Lives of Eminent Philosophers,
  73. (2003). MDA Explained: The Model Driven Architecture: Practice and Promise. Addison-Wesley Object Technology Series.
  74. (1997). Metrics and laws of software evolution - the nineties view.
  75. (2006). Model checking dynamic states in groove. In
  76. (2004). Model checking graph transformations: a comparison of two approaches.
  77. (1994). Model checking using net unfoldings.
  78. (2003). Model refactorings as rule-based update transformations.
  79. (2006). Model transformation by example.
  80. (2006). Object Constraint Language, version 2.0,
  81. (2008). Object-Oriented Reengineering Patterns. Square Bracket Associates,
  82. (1991). Object-preserving class transformations.
  83. (2008). Ole Kniemeyer, Anantha Narayanan, Edgars Rencis, and Erhard Weinell. Transformation of uml models to csp: A case study for graph transformation tools.
  84. (1996). Organisation. Information technology - Syntactic metalanguage - Extended BNF,
  85. (1996). Parallel Composition and Unfolding Semantics of Graph Grammars.
  86. (2008). Parallelism and concurrency in adhesive high-level replacement systems with negative application conditions.
  87. (1985). Petri Nets: An Introduction.
  88. (1999). Practical analysis for refactoring.
  89. (1998). Reengineering object-oriented code.
  90. (2003). Refactoring browser with preprocessor. In
  91. (2003). Refactoring for generalization using type constraints.
  92. (1992). Refactoring Object-Oriented Frameworks.
  93. (2008). Refactoring ocl annotated uml class diagrams.
  94. (2003). Refactoring reusable business components.
  95. (2004). Refactoring to Patterns. The Addison-Wesley Signature Series.
  96. (2001). Refactoring uml models.
  97. (1999). Refactoring: Improving the Design of Existing Code. AddisonWesley Professional, 1st edition edition,
  98. (1997). Refinement of information flow architectures.
  99. (2009). Reiko Heckel, and Hartmut Ehrig. Compositional verification of architectural refactorings.
  100. (2009). Reiko Heckel, and Hartmut Ehrig. Compositionality of model transformations.
  101. (2009). Reiko Heckel, and Hartmut Ehrig. Verification of architectural refactorings: Rule extraction and tool support.
  102. (2003). Reusing intellectual assets,
  103. (1990). Reverse engineering and design recovery: A taxonomy.
  104. (2007). Rule-level verification of business process transformations using csp.
  105. (2006). Semantic-Based Development of Service-Oriented Systems.
  106. (1987). Semantics and implementation of schema evolution in object-oriented databases.
  107. (1994). Specification of graph translators with triple graph grammars.
  108. (1998). Specifying and analyzing dynamic software architectures.
  109. (2004). Specifying integrated refactoring with distributed graph transformations.
  110. (2004). State space abstraction using shape graphs.
  111. (2006). Stochastic graph transformation systems.
  112. (1979). Structured Design: Fundamentals of a
  113. (1993). Symbolic Model Checking.
  114. (2007). Team. Tiger EMF Transformer,
  115. (1999). Term graph rewriting.
  116. (2007). Termination criteria for dpo transformations with injective matches.
  117. (2005). Termination of high-level replacement units with application to model transformation.
  118. (2006). Termination Properties of Model Transformation Systems with Srtict Control Flow.
  119. (1992). The design of distributed systems - an introduction to focus.
  120. (2004). The GROOVE simulator: A tool for state space generation.
  121. (2004). The Object Primer: Agile Modeling-Driven Development with UML 2.
  122. (1994). The program structure tree: computing control regions in linear time.
  123. (1997). Theory and Practice of Concurrency.
  124. (2005). Towards attributed graphs in groove.
  125. (2003). Towards automating source-consistent UML refactorings.
  126. (2003). Towards model checking graph grammars.
  127. (2005). Towards proving preservation of behaviour of refactoring of uml models.
  128. (2008). Towards the verification of attributed graph transformation systems.
  129. (1987). Tutorial introduction to the algebraic approach of graph grammars.
  130. (1986). Tutorial on software restructuring.
  131. (1999). Unfolding and event structure semantics for graph grammars.
  132. (2007). Unfolding Semantics of Graph Transformation.
  133. (2005). Unified Modeling Language version 2.0: In support of modeldriven development,
  134. (2006). Unified Modeling Language, version 2.1.1,
  135. (2008). Using graph transformation systems to specify and verify data abstractions.
  136. (2008). Verification of architectural refactorings by rule extraction.
  137. (2008). Verification of architectural refactorings: Rule extraction and tool support.
  138. (2004). Verifying finite-state graph tranformation grammars: an unfolding-based approach.

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.