Refinement of Software Architectures by Recursive Model Transformations (original) (raw)
Related papers
Software architecture design by stepwise model transformations: A comparative case study
2015 3rd International Conference on Model-Driven Engineering and Software Development (MODELSWARD), 2015
Software architecture design is a critical task as lots of requirements can be taken into account on which many decisions can be made. The maintenance and evolution of resulting models often become tricky, even impracticable when their rationale is lost. In a previous work, we introduced a set of languages used in a transformation-centric design method meant to tackle this scattering of requirements and to facilitate further model evolutions. But, we did not provided a formal validation of our proposal yet. The present work depicts a comparative case study we conducted on a group of students. The participants were asked to develop an online book store in two phases, the second one simulating an evolution of the system. We evaluated the functional completeness of the created software as well as the traceability of design decisions and rationale. The participants were also asked to criticize the design method and language they used in a textual report and through a questionnaire. Even...
ARCHITECTING SOFTWARE SYSTEMS USING MODEL TRANSFORMATIONS AND ARCHITECTURAL FRAMEWORKS
Software systems have become essential to many human activities and have proliferated thanks to various hardware innovations such as mobile computing (laptops, personal digital assistants, mobile phones) and networks (DSL, WIFI, GSM, etc.) enabling interactions between users and computer systems in virtually any place. This situation has created both a great complexity for such distributed systems to be designed and great expectations (mainly concerned with quality, time and induced costs of the software) from the users of these systems, requiring improvements in software engineering methods in order to meet these challenges.
A UML class diagram-based pattern language for model transformation systems
Proceedings of the 4th …, 2005
Model transformation methods are vital in several applications such as OMG's Model-Driven Architecture and Visual Model Processors. This paper contributes a metamodel-based rewriting rule representation similar to the UML class diagram and the supporting algorithms to determine valid instances of the patterns. The proposed algorithms are illustrated by specific examples throughout the paper. The results turn out to be useful not only for UML class diagram-based rewriting rule formulation patterns, but it provides a method for checking valid instantiation of UML class diagrams in modeling environments.
Automatic Reengineering in MDA Using Rewriting Logic as Transformation Engine
Ninth European Conference on Software Maintenance and Reengineering, 2005
Legacy systems are information systems that have been developed by means of methods, tools and database management systems that have become obsolete, but they are still being used due to their reliability. As time goes on, the maintenance of this software becomes more complex, expensive and painful. The OMG's MDA initiative provides some guides to develop software that raise models and transformations between them as first class citizens. This point of view provides a precise way to develop a new application from the legacy one. The MOMENT Framework supports automatic formal model transformations in MDA. This model transformation approach is based on the algebraic specification of models and benefits from mature term rewriting system technology to perform model transformation using rewriting logic. In this paper, we present how we apply this formal transformation mechanism to recover a legacy relational database, obtaining a UML-based application. This approach keeps the legacy knowledge by pumping the legacy data to the new database generated from the UML model. Our approach enhances the integration between formal environments and industrial technologies such as .NET technology, and exploits the best features of both.
Conference on Software Maintenance and Reengineering (CSMR'06), 2006
Software-intensive systems evolve continuously under the pressure of new and changing requirements, generally leading to an increase in overall system complexity. In this respect, to improve quality and decrease complexity, software artifacts need to be restructured and refactored throughout their lifecycle. Since software architecture artifacts represent the highest level of implementation abstraction, and constitute the first step in mapping requirements to design, architecture refactorings can be considered as the first step in the quest of maintaining system quality during evolution. In this paper, we introduce an approach for refactoring software architecture artifacts using model transformations and quality improvement semantic annotations. First, the conceptual architecture view is represented as a UML 2.0 profile with corresponding stereotypes. Second, instantiated architecture models are annotated using elements of the refactoring context, including soft-goals, metrics, and constraints. Finally, the actions that are most suitable for the given refactoring context are applied after being selected from a set of possible refactorings. The approach is applied to a simple example, demonstrating refactoring transformations for improved maintainability, performance, and security.
An Approach for Design of Architectural Solutions Based on Software Model-To-Model Transformation
2017
Software models are central software development artifacts in Model-Driven Software Engineering (MDSE) approach. During the Requirements Analysis, Software Design and Software Development a variety of software models, represented as UML diagrams, are created. However, in a majority of software development approaches they are designed mainly. Considering the fact that new software models contain information from previous ones, software Model-to-Model transformation techniques facilitate the process of new software models obtaining by means of reusing information from software models created before. An approach for performing Model-to-Model transformation, which is based on graph transformation, is presented in this paper. Transformational operations are considered on meta-level and concrete level. Software models are represented as graphs. Software tool, that allows performing transformation from communication diagram to class one, is described. This tool is designed as a plug-in for...
Software Architectures: Multi-Scale Refinement
2016 IEEE 14th International Conference on Software Engineering Research, Management and Applications (SERA), 2016
We propose a multi-scale modeling approach for complex software system architecture description. The multi-scale description may help to obtain meaningful granularities of these systems and to understand and master their complexity. This vision enables an architect designer to express constraints concerning different description levels, oriented to facilitate adaptability management. We define a correct-by-design approach that allows a given abstract architectural description to be refined into architecture models. We follow a progressive refinement process based on model transformations; it begins with a coarsegrain description and ends with a fine-grain description that specifies design details. The adaptability property management is performed through model transformation operations. The model transformation ensures the correctness of UML description, and the correctness of the modeled system. We experimented our approach with a use case that models a smart home system for the monitoring of elderly and disabled persons at home.
Architecting software systems using model transformation and architectural frameworks
2007
Software systems have become essential to many human activities and have proliferated thanks to various hardware innovations such as mobile computing (laptops, personal digital assistants, mobile phones) and networks (DSL, WIFI, GSM, etc.) enabling interactions between users and computer systems in virtually any place. This situation has created both a great complexity for such distributed systems to be designed and great expectations (mainly concerned with quality, time and induced costs of the software) from the users of these systems, requiring improvements in software engineering methods in order to meet these challenges. On the one hand, Model Driven Engineering (MDE), by allowing the description of software systems through abstractions and deriving useful system artifacts, harnesses inherent complex- ity of software systems and reduces time-to-market via model transformations. On the other hand, software product lines foster software reuse by proposing to develop applications based on a set of common assets belonging to a particular domain. Thus, when product line assets are carefully designed, both quality and time-to-market requirements can be achieved. Development methods that have resulted from the product line paradigm generally focus on defining common and variable assets to be reused by product line members. However, they hardly address the development of applications from the product line assets in a systematic way. Furthermore, those considering it propose automated but rather inflexible approaches that unnecessarily ex- clude products which, although addressable by product line assets, have not been explicitly envisioned during product line definition. If in some domains — in particular, those including hardware constraints and/or critical features — it is possible to fully determine the products that are part of the software product line, in the other cases, an initial set of products can only be considered assuming that the customers’ requests will be met by this set. We believe that this assumption is false in general and this thesis examines the research question which consists in proposing a set of models and a product line development method to offer more flexibility while deriving products in order to seamlessly address customers’ requests. The domain we consider is that of web e-bartering systems. This thesis strives to propose a trade-off between automated and unsupported product deriva- tion by providing a model-driven product line development method that allows developers to define product line members by transforming a coherent and layered set of product line models. Moreover, constraints on the possible transformations have to be specified in order to determine which products cannot be derived both for functional and technical reasons. The first part of this thesis introduces the foundational concepts of our FIDJI method. In par- ticular, it describes the notion of architectural framework as a set of models defining product line assets at analysis and design levels and which is instantiated in order to obtain product line members thanks to model transformations. This part then describes key methodological principles driving the choice of architectural framework models and how flexibility in product derivation can be achieved and controlled by constraints defined over the set of architectural framework models. The second part of this thesis is devoted to requirements elicitation, analysis and design phases of the method. For requirements elicitation, a specific product line template is defined to allow for the description of a software product line in an informal manner via use case variants and data dictionaries. The analysis phase refines requirements elicitation by allowing the precise description of domain concepts in terms of UML models as well as functionalities in terms of use cases completed by OCL expressions. Variability is ensured through the use of state variables in OCL expressions which enable a wide variety of scenarios to be implemented in the product. Constraints indirectly define product line boundaries by preventing certain instantiations from being made. The design phase focuses on the architectural design of the architectural frame- work and describes it in terms of interacting components structured via architectural styles. Analysis and design models are supported by UML profiles defining the constructs offered by the FIDJI method, their usage conditions as well as traceability and consistency rules ensuring model correctness. The methodological process for both analysis and design consists in writing a transformation program, validated over the aforementioned constraints, that will instantiate the architectural framework to obtain a viable product line member. The last part of the thesis deals with the practical application of the method. A case study belonging to the e-commerce domain illustrates the FIDJI method in detail and a simple archi- tectural framework is defined for this purpose. In particular, we show how the transformation program is created from predefined transformation operations dedicated to FIDJI models and the rationale and usage of constraints controlling the instantiation of the architectural framework.
Generating operation specifications from UML class diagrams: A model transformation approach
Data & Knowledge Engineering, 2011
One of the more tedious and complex tasks during the specification of conceptual schemas (CSs) is modeling the operations that define the system behavior. This paper aims to simplify this task by providing a method that automatically generates a set of basic operations that complement the static aspects of the CS and suffice to perform all typical life-cycle create/update/delete changes on the population of the elements of the CS. Our method guarantees that the generated operations are executable, i.e. their executions produce a consistent state wrt the most typical structural constraints that can be defined in CSs (e.g. multiplicity constraints). In particular, our method takes as input a CS expressed as a Unified Modeling Language (UML) class diagram (optionally defined using a profile to enrich the specification of associations) and generates an extended version of the CS that includes all necessary operations to start operating the system. If desired, these basic operations can be later used as building blocks for creating more complex ones. We show the formalization and implementation of our method by means of model-tomodel transformations. Our approach is particularly relevant in the context of Model Driven Development approaches.
An Approach for Modeling Architectural Design Rules in UML and its Application to Embedded Software
ACM Transactions on Software Engineering and Methodology, 2012
Current techniques for modelling software architecture do not provide sufficient support for modelling of architectural design rules. This is a problem in the context of Model-Driven Development in which it is assumed that major design artefacts are represented as formal or semi-formal models. This paper addresses this problem by presenting an approach to modelling architectural design rules in UML at the abstraction level of the meaning of the rules. The high abstraction level and the use of UML makes the rules both amenable to automation and easy to understand for both architects and developers, which is crucial to deployment in an organization. To provide a proof-of-concept a tool was developed that validates a system model against the architectural rules in a separate UML model. To demonstrate the feasibility of the approach the architectural design rules of an existing live industrial strength system were modelled according to the approach.