Architecture Migration Driven by Code Categorization

2009

Implementations of existing systems often do not follow the originally intended architecture. Continous extension disregarding the intended architecture leads to a decline of the maintainability of these systems. To recover maintainability architectural restructuring becomes necessary. We present a model-based architecture restructuring approach that is based on business requirements. The goal of the approach is to semi-automatise the architecture restructuring process in order to support reengineers. We use graph clustering to implement the automatisation.

As software architecture evolution has become an integral part of the automated software engineering lifecycle, reuse, modularization and composition of evolution rules becomes more important. This paper aims to generalize the architecture evolution model by defining evolution rules and propagation strategies on graphs describing software architectures. We aim to define a user-definable means to manage software architecture evolution model.

2012 International Conference on Advanced Computer Science Applications and Technologies (ACSAT), 2012

As software architecture evolution has become an integral part of the automated software engineering lifecycle, reuse, modularization and composition of evolution rules becomes more important. This paper aims to generalize the architecture evolution model by defining evolution rules and propagation strategies on graphs describing software architectures. We aim to define a user-definable means to manage software architecture evolution model.

… and Parallel/Distributed Computing, 2005 and …, 2005

Architectural refactorings are an appropriate technique for the development and improvement of architectural specifications. However, these refactorings are often applied manually. This paper presents a mapping of an architectural specification language to a hypergraph-based data structure. Thus, architectural refactorings can be formalized as hypergraph transformation rules and can be applied automatically.

2017

While aspect-oriented programming (AOP) addresses introduction of “aspects” at the code level, we argue that addressing this at the level of software architecture is conceptually more adequate, since many aspects, that is, “crosscutting concerns”, are formulated already in the requirements, and therefore can be dealt with in a more controlled manner in the “earlier” phase of software architecture design. We use Fiadeiro and Maibaum’s [11] precise concept of software architectures organized as diagrams over a category of component specifications, where architecture semantics is defined as the colimit specification of the diagram. The diagram structure suggests aspect introduction via an appropriate variant of graph transformation. Single-pushout rewriting in categories of total homomorphisms has previously already been used for different kinds of “enrichment” transformations; we identify “zigzag-path homomorphisms” as underlying a category where many practically useful aspect introdu...

Proceedings of the 1st Workshop on View-Based, Aspect-Oriented and Orthographic Software Modelling, 2013

The transformation of component-based architectures into object-oriented source code for different platforms is a common task in Model-Driven Software Development. Reusing parts that are common to all supported target-platforms for several model-to-text transformations is challenging. Existing approaches, like parameterized transformations and modularity concepts for transformations, make the reuse of transformations parts easier, but cannot be used to visualize design decisions that are common to all supported target-platforms. In this paper, we propose that platformindependent design decisions and their transformation results should be made explicit in an intermediate view. A single parameterized transformation should yield a common objectoriented model before individual transformations for specific platforms are executed. We argue that the additional view makes it possible to analyze decisions on how a component architecture is implemented and increases the maintainability by decoupling the involved transformations.

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.

Since software architecture has become integral part of software development, managing its evolution has become the concern of most of architecture researchers. In this paper, we define firstly a Generic-ADL (Architecture Description Language) which includes all important and common concepts in the existing ADLs to describe software architectures. Secondly, we propose a second model named EVA-Model (Evolution and Versioning Architecture) to manage the software architecture evolution and their versioning. Based-on the proposed EVA-Model, we implement the evolution and the versioning mechanisms using model transformation approach through ATL language. However, these ATL transformations present tow challenges: the absence of the genericity concept and the rule scheduling mechanism. We address these issues by proposing parameter model to generalize the transformations and by using java technology to allow users managing the parameters and to handle the execution order of evolution transformations where each evolution transformation is followed transparently by a versioning one.

Software Engineering Research and Practice, 2006

Software evolution is inevitable due to changes in requirements and technology. Software quality and productivity are critical to software evolution. Architecture-centric evolution has the advantage of improving quality attributes; however, it does not directly address the issue of the time needed for evolution. This paper proposes an architecture-centric program transformation approach to support both quality and productivity concerns. The approach emphasizes the analysis of similarities and differences among architecture alternatives, which facilities the tool development for architecture evolution or evaluation. A tool was constructed to automatically transform a program to another form based on user's selection. The tool currently supports the transformation of one traditional design to the other two commonly used architecture patterns in distributed and concurrent systems.

2003

ABSTRACT Modern architectural styles, like the service-oriented style underlying web services, are highly dynamic. This complicates not only their practical application, but also the modeling and prediction of their behavior. To account for this problem, we propose to model architectures as graphs, represented as instances of UML class diagrams, and to describe their reconfigurations by graph transformation rules.