Software Architecture Evolution Research Articles

Software engineering architecture and its promising opportunities

The evolution of software architecture has witnessed the transition from monolithic to microservices, offering enhanced scalability, maintainability, and flexibility. With the rise of Microservices Architecture (MA), containerization has emerged as a pivotal technology to encapsulate microservices in isolated environments, ensuring consistent deployment. This paper delves into the intricate relationship between Microservices Architecture and containerization, focusing on the benefits, challenges, and practical implications of integrating both. Through a comprehensive experimental setup simulating an e-commerce platform, we quantitatively evaluate the performance metrics of a containerized microservices system versus a traditional monolithic setup. Our findings accentuate the performance gains achieved through MA and containerization, while also shedding light on areas that demand caution and further research. The insights presented serve as a beacon for organizations aiming to transition to or optimize their microservices and containerization practices.

A Prediction Method for Evolution Effects of Software Architecture

Software architecture evolution may lead to architecture erosion, resulting in the increase of software maintenance cost, the deterioration of software quality, the decline of software performance, and so on. In order to avoid software architecture erosion, we should evaluate the evolution effect of software architecture in time. This paper proposes a prediction method for the evolution effects of software architecture based on BP network. Firstly, this method proposes four evolution principles and evaluates the overall evolution effects based on the combined measurements. Then, we extract the evolutionary activities from release notes. Finally, we establish a prediction model for evolution effect based on BP network. Experimental results show that the proposed method can be used to predict the evolution effect.

Towards the Software Evolution Recovery at the Level of Software Architecture

In the process of software evolution, a lot of evolution history information will be stored in software repository. Because some open source repositories (such as GitHub) only record the version of every source file, it is difficult for people to comprehend and manage the evolution of software component and software architecture. In the paper, we propose the concept of software evolutionary binary tree to present the evolution history of software architecture and its components, propose a method to recover them by software architecture recovery technology as well. The experimental results of four open source software (Cassandra, Hbase, Hive and Openjpa) demonstrate that the method is effective.

Modelling and Planning Evolution Styles in Software Architecture

The purpose of this study is to find the right model to plan and predict future evolution paths of an evolving software architecture based on past evolution data. Thus, in this paper, a model to represent the software architecture evolution process is defined. In order to collect evolution data, a simple formalism allowing to easily express software architecture evolution data is introduced. The sequential pattern extraction technique is applied to the collected evolution styles of an evolving software architecture in order to predict and plan the future evolution paths. A learning and prediction model is defined to generate the software architecture possible future evolution paths. A method for evaluating the generated paths is presented. In addition, we explain and validate our approach through a study on two examples of evolution of component-oriented software architecture.

Towards a reference process for software architecture reconstruction

Nowadays, software systems remain useful and competitive; entail the inevitable need to change over time and to be adapted to new technologies, platforms, and architectures. These quick changes imply following systematic, automated, or standardised processes that provide recommendations and guidelines to architects during software architecture reconstruction. Considerable research work on architecture reconstruction has been conducted. However, it needs to be studied thoroughly to determine what are the common activities and elements to reconstruct software architectures, and to define a reference process for systematically guiding the evolution of software architectures. This work addresses the need for defining a process for software architecture reconstruction called software improvement in the reconstruction of architectures (SIRA). This process has been rigorously designed from the results of a systematic literature review and a small survey of related work. As a result, SIRA integrates and extends previous research and can be conceived as a reference process to reconstruct software architectures in a semi-automated way. In addition, this work also determines the common elements of the architecture reconstruction process: (i) techniques and activities; (ii) architectural elements, patterns, and attributes; (iii) mechanisms and strategies; and (iv) the automation and recommendation tasks of the process.

Bigraph specification of software architecture and evolution analysis in mobile computing environment

Software system evolution is an active and important research topic in software engineering. In guiding software system evolution, software architecture plays a critical role. In the traditional software architecture, only the link information of components is considered, while the place information of components is usually neglected. However, due to the emerging mobile computing, pervasive computing, and intelligent computing, the place information is as important as the link information in the software architecture. Especially in mobile computing environments, the place changes often lead to changes in software configuration and functionality. In this paper, we study the Bigraph specification of software architecture and use it to describe both link and place information in detail. Based on Bigraph specification, we investigate the structural characteristics in the software architecture, and design checking algorithms for the component’s link exceptions and place exceptions. Furthermore, we address the well-evolved software architecture from a new perspective, which includes three basic evolution operation rules and their well-evolved conditions. We discuss the overall software architecture evolution through strong and weak bi-simulation in terms of software functionality. Finally, two case studies about software system in the evolution operation are presented, which illustrate the effectiveness of our approach.

A Systematic Mapping on Visual Solutions to Support the Comprehension of Software Architecture Evolution

A Systematic Mapping on Visual Solutions to Support the Comprehension of Software Architecture Evolution

Mining Patterns from Change Logs to Support Reuse-Driven Evolution of Software Architectures

Modern software systems are subject to a continuous evolution under frequently varying requirements and changes in systems’ operational environments. Lehman’s law of continuing change demands for long-living and continuously evolving software to prolong its productive life and economic value by accommodating changes in existing software. Reusable knowledge and practices have proven to be successful for continuous development and evolution of the software effectively and efficiently. However, challenges such as empirical acquisition and systematic application of the reusable knowledge and practices must be addressed to enable or enhance software evolution. We investigate architecture change logs — mining histories of architecture-centric software evolution — to discover change patterns that 1) support reusability of architectural changes and 2) enhance the efficiency of the architecture evolution process. We model architecture change logs as a graph and apply graph-based formalism (i.e., graph mining techniques) to discover software architecture change patterns. We have developed a prototype that enables tool-driven automation and user decision support during software evolution. We have used the ISO-IEC-9126 model to qualitatively evaluate the proposed solution. The evaluation results suggest that the proposed solution 1) enables the reusability of frequent architectural changes and 2) enhances the efficiency of architecture-centric software evolution process. The proposed solution promotes research efforts to exploit the history of architectural changes to empirically discover knowledge that can guide architecture-centric software evolution.

A Verification‐Based Approach to Evaluate Software Architecture Evolution

As the development and wide usage of Software architecture (SA), SA evolution becomes one of the hotspots of current research in modern software engineering domain. Most current researches concentrate on the modeling of SA evolution and lack the verification and evaluation of SA evolution. We proposed a verificationbased approach to evaluate SA evolution. The basic process includes:1) using Unified modeling language (UML) sequence diagram to model the interaction of components and study different types of evolution in practical examples; 2) using SPIN-based model checking to model and verify SA evolution; 3) comparing various verification outcomes and analyzing the influence of SA evolution on SA correctness and temporal properties. Both theory analysis and an experiment on a real evolution example from Model-view controller (MVC) to Spring web MVC (SWMVC) show that the verification-based approach to evaluate SA is significant.

A Specification and Detection Approach for Parallel Evolution Conflicts of Software Architectures

Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.

A design-by-contract approach to recover the architectural style from run-time misbehaviour

We propose to control the reconfigurations of applications leading to an erroneous state by exploiting its architectural model. Our work relies on Architectural Design Rewriting (ADR, for short) which is a rule-based formal framework for modelling (the evolution of) software architectures. We equip the reconfiguration rules of an ADR architecture with pre- and post-conditions expressed in a simple logic; a pre-condition constraints the applicability of a rule while a post-condition specifies the properties expected of the resulting graphs. We give an algorithm to compute the weakest pre-condition out of a rule and its post-condition. On top of this algorithm, we design a simple methodology that allows us to select which rules can be applied at the architectural level to reconfigure a system so to regain its architectural style when it becomes compromised by unexpected run-time reconfigurations.

Modeling Software Architecture Evolution for Electronic Commerce System Based on Graph Representation

With the rapid development of mobil internent and internet of things,most of electronic commerce systems need to be improved.Software architecture evolution for electronic commerce system provides an important technology measure for its improvement work. This paper try to model software architecture evolution of e-commerce based on graph representation.Firstly the paper apply a graph to represent SA of a e-commerce system,and give its formulazation description.Then establish some basic evolution rules for software architecture evolution of electronic commerce system on the basis of defining graph transformation rule,software architecture evolution operations for electronic commerce can be carryed out according to these evolution rules.Finally through an evolution case, the sophisticated process of software architecture evolution for the electronic commerce system is described.This research work can help to upgrade the electronic commerce. system.

Trusted Software Architecture Evolution Based on Graph Transformation Rule

In current software architecture evolution community, Trusted attributes of component are less considered; and the concept of trusted software architecture evolution has not generally agreed. Focused on above shortages, This paper propose the idea of trusted software architecture evolution, it helps to increase the trustworthiness of evolution; on the basis of graph transformation rule, establish some basic evolution rules, Evolution operations are implemented according to these evolution rules. It can ensure the exactness of evolution process. The paper also introduce E-R diagram to represent trusted software architecture evolution; and finally through an evolution case, exactly and visually describes the sophisticated evolution process of trusted software architecture evolution.

A pattern language for the evolution of component-based software architectures

Architecture-centric software evolution enables change in a system’s structure and behaviour while maintaining a global view of the software to address evolution-centric trade-offs. The existing solutions for architectural maintenance and evolution fall short of exploiting generic and reusable expertise to address recurring evolution problems. We present a pattern language as a collection of interconnected change patterns that enable reuse-driven and consistent evolution of component-based software architectures. Pattern interconnections represent possible relationships among patterns (such as variants or related patterns) in the language. In general, we introduce architecture change mining (pattern language development) as a complementary and integrated phase to facilitate reuse-driven architecture change execution (pattern language application). We evaluate the language applicability to support pattern-driven reuse in architecture evolution of a payment system case study. We also analyse the precision and recall factor as a measure of selecting the most appropriate pattern(s) from the language collection. The pattern language itself continuously evolves with an incremental discovery of new patterns from change logs over time

A framework for acquisition and application of software architecture evolution knowledge

Software systems continuously evolve as a consequence of frequent changes in their functional requirements and the environment surrounding them. Architecture-centric software evolution (ACSE) enables changes in software structure and behaviour while abstracting the complex implementation-specific details. However, due to recurring evolution there is a need for solutions that enable a systematic reuse of frequent changes in software architectures. In recent years, architecture change patterns and evolution styles proved successful in promoting reuse expertise to tackle architecture evolution. However, there do not exist any solutions that enable a continuous acquisition and application of architecture evolution knowledge to systematically address frequent changes in software architectures. In this paper, we propose a framework PatEvol that aims to unify the concepts of i) software repository mining and ii) software evolution to enable acquisition and application of architecture evolution knowledge. In the proposed PatEvol framework, we present knowledge acquisition ( architecture evolution mining ) to enable post-mortem analysis of evolution histories to empirically discover evolution-centric knowledge. Furthermore, we support reuse of discovered knowledge to enable knowledge application ( architecture evolution execution ) that enables evolution-off-the-shelf in software architectures. Tool support facilitates the knowledge acquisition and knowledge application processes in the PatEvol framework.

MODELING AND VERIFYING COMPOSITE DYNAMIC EVOLUTION OF SOFTWARE ARCHITECTURES USING HYPERGRAPH GRAMMARS

As software systems become more and more complex, there is need to consider not only data structures and algorithms but also the general structure or architecture of the system. Many researchers have presently focused on dynamic evolution of software architectures. Most of them usually emphasized on describing and analyzing the dynamic evolution process of software architectures, while lacking formally modeling and verifying composite dynamic evolution of software architectures. In this paper, we propose a formal method of modeling and verifying composite dynamic evolution of software architectures using hypergraph grammars. We represent software architectures with hypergraphs, give out corresponding composite evolution rules of software architectures, and then model composite dynamic evolution of software architectures according to those rules. At last we verify the liveness property of composite dynamic evolution of software architectures using model checking, and give out corresponding verification algorithms. Our approach provides a graphical representation for composite dynamic evolution of software architectures, and displays a formal theoretical basis on grammars.

A Lightweight Modeling and Verifying Method for Dynamic Evolution of Software Architectures Using Alloy

A Lightweight Modeling and Verifying Method for Dynamic Evolution of Software Architectures Using Alloy

Evolution styles: foundations and models for software architecture evolution

As new market opportunities, technologies, platforms, and frameworks become available, systems require large-scale and systematic architectural restructuring to accommodate them. Today’s architects have few techniques to help them plan this architecture evolution. In particular, they have little assistance in planning alternative evolution paths, trading off various aspects of the different paths, or knowing best practices for particular domains. In this paper, we describe an approach for planning and reasoning about architecture evolution. Our approach focuses on providing architects with the means to model prospective evolution paths and supporting analysis to select among these candidate paths. To demonstrate the usefulness of our approach, we show how it can be applied to an actual architecture evolution. In addition, we present some theoretical results about our evolution path constraint specification language.

Retraction notice to ‘‘Specification and Verification of Dynamic Evolution of Software Architectures” [SYSARC 56 (10) (2010) 523–533

Retraction notice to ‘‘Specification and Verification of Dynamic Evolution of Software Architectures” [SYSARC 56 (10) (2010) 523–533

Software architecture evolution through evolvability analysis

Software evolvability is a multifaceted quality attribute that describes a software system's ability to easily accommodate future changes. It is a fundamental characteristic for the efficient implementation of strategic decisions, and the increasing economic value of software. For long life systems, there is a need to address evolvability explicitly during the entire software lifecycle in order to prolong the productive lifetime of software systems. However, designing and evolving software architectures are the challenging task. To improve the ability to understand and systematically analyze the evolution of software system architectures, in this paper, we describe software architecture evolution characterization, and propose an architecture evolvability analysis process that provides replicable techniques for performing activities to aim at understanding and supporting software architecture evolution. The activities are embedded in: (i) the application of a software evolvability model; (ii) a structured qualitative method for analyzing evolvability at the architectural level; and (iii) a quantitative evolvability analysis method with explicit and quantitative treatment of stakeholders’ evolvability concerns and the impact of potential architectural solutions on evolvability. The qualitative and quantitative assessments manifested in the evolvability analysis process have been applied in two large-scale industrial software systems at ABB and Ericsson, with experiences and reflections described.