Consistency Analysis of Dynamic Evolution of Software Architectures Using Constraint Hypergraph Grammars

In order to solve the problem of the complexity of software system and the efficiency of large-scale collaboration, software architecture design methods have gradually developed. In the process of software architecture evolution, users and concurrency are increasing day by day, and software technology is constantly evolving and improving accordingly. Although there are many researches and technical discussions on software architecture methodology, there are few papers that fully discuss the development of technology in terms of the evolution of the architecture. This paper takes the evolution of software architecture as the research object, discusses problems, solutions and related technologies involved in the evolution of software architecture, and comprehensively explains how the system gradually evolves from a single architecture to a complex high-concurrency architecture. KeywordsArchitecture designArchitecture evolutionHigh concurrency

Change is an intrinsic property of software.A software system, during its lifetime, may require several updates, improvements, or new features.If these change requirements are not addressed, the risk of becoming a useless system increases.In fact, this is a challenging issue of safety-and mission-critical software systems, which cannot be stopped to perform maintenance or evolution operations due to their continuous operation.To reduce the aging of these critical systems, they must be provided with mechanisms enabling their dynamic evolution, i.e. the support of changes on their structure and behaviour while they remain in operation.This thesis is concerned with the design of a framework to build architecturebased, dynamically evolvable, software systems.The fact that this framework is a software architecture based approach provides the following advantages: (i) it offers a high-level of abstraction for describing dynamic changes; (ii) it allows varying the level of system description; and (iii) it advantages from the existing support for system modelling, code-generation, and formal analysis provided by architecture description languages.The framework presented in this thesis, called Dynamic PRISMA, is characterized by the combination of two levels of dynamism: Dynamic Reconfiguration, which addresses changes at the configuration level (i.e. the architectural configuration), and Dynamic Type Evolution, which addresses changes at the type-level (i.e. the specification of architectural types and instances).This combination is one of the major contributions of this thesis: thus a system is not only able to reconfigure at runtime the building blocks it is composed of (i.e.architectural types), but also to redefine these building blocks (or introduce new ones) at runtime.Another contribution of the thesis is the identification of the concerns related to dynamic evolution and their integration in the framework through aspects.This improves the separation of concerns and allows us to change reconfiguration specifications, evolution mechanisms, or the business logic independently of each other.A third contribution of this thesis is how this dynamism is supported: reconfiguration through autonomic capabilities, which provides proactivity according to either internal or external stimuli; and type evolution through asynchronous reflection, which enables the modification of a type specification and the transformation of their instances at different rates (i.e. when they are ready for evolution).Specifically, the asynchronous evolution vi semantics is precisely described by means of graph transformations.This formalism has been chosen because it naturally models both the system architecture and its asynchronous evolution.The work presented in this thesis is illustrated through a case study from the robotics domain; an area which could potentially benefit from the results of this thesis.

Welcome you to the Fifth Edition of the track Software Architecture: Theory, Technology, and Applications (SA-TTA 2017) as part of the 32th ACM/SIGAPP Symposium on Applied Computing (SAC).

Modern computing and network environments demand ahigh degree of adaptability from applications. At run time, an application may have to face many changes: in configuration, in protocols used, in terms of the available resources, etc. Many such changes can only be adequately addressed through dynamic evolution of the software architecture of the application. In this paper, we propose a novel approach to dynamically evolve a software architecture based on run-time aspect oriented programming. In our framework, a system designer/administrator can control the architecture of an application by dynamically inserting and removing code extensions. It is even possible to replace a significant part of the underlying middleware infrastructure without stopping the application. The novelty of this work is that it allows for a much more flexible development strategy as it delegates issues like middleware choice and adherence to an architectural specification to a framework enhanced by dynamic code extensions.

The software industry increasingly needs to consider architecture evolution in the context of industrial ecosystem platforms. These environments feature a large number third-party offerings with a high variety and complexity of design and technology options. The software architects working on platform migration and in-platform evolution scenarios in such environments require support to find and utilize optimal offerings, ensure design compatibility with various technical and non-technical constraints, and optimize architectures. Based on a multi-case study of three industrial cases, we have derived an architecture knowledge model that provides a basis for supporting software architects in platform migration and in-platform evolution scenarios.

Managing evolution of complex software architecture is a continuous challenge in industry. Systems such as mobile handsets undergo a continuous increase in complexity, while the fast market evolution imposes quick integration of new features. Being able to easily manage software architecture evolution is the basis for shorter time-to-market and faster product release. The term “viewpoint” has become familiar with the publication of the IEEE standard 1471–2000 on recommended practices for architectural modelling. Based on the classical 4+1 view model, we have elaborated our own set of viewpoints in order to support our domain-specific architectural modelling needs. We hereby justify the introduction of the architectonic viewpoint, which models the evolutionary aspects of software architecture. The term, as well as the rationale behind it, is inspired from architecture as in buildings. We describe the viewpoint and the way it links to the others we use. Additionally, we briefly elaborate on the other viewpoints that we use for architectural modelling of mobile telephone software architecture. We provide basis for discussion and further research into the matter.

Software development is a dynamic process where engineers constantly modify and refine systems. As a consequence, system architecture evolves over time. Software architectural evolution has been managed at different abstraction levels: the meta level, the architectural level, the application level, the implementation level, etc. However, the management supports for architectural evolution are limited to evolution mechanisms in architectural description languages such as subtyping, inheritance, interface, and genericity. This paper presents a model-oriented version and configuration control approach to managing the evolution of architectural entities in configurations at different abstraction levels as well as logical relationships among them. This paper also illustrates our approach in building an architectural configuration management system that is capable of managing configurations and versions of software architecture across multiple levels of abstraction in a uniform and tightly connected manner

Self-adaptive systems, which enable runtime adaptation, are promising ways of dealing with environmental changes, including system intrusions or faults. Such software systems must modify themselves to better fit their environment. One of the main approaches to constructing such systems is to introduce multiple control loops. Software evolution is an essential activity for expanding this adaptation capability, and dynamic evolution has been envisaged as a way of systems adapting themselves at runtime. In this paper, we establish a development process to deal with dynamic evolution. We devise a goal model compiler to generate models for designing dynamic evolutions and a programming framework that supports dynamic deployment of control loops. We experimentally applied our approach to a system and discuss how our compiler and framework support dynamic evolution of self-adaptive systems.

Metric-based Evaluation of Implemented Software Architectures

As the ability of a single agent is limited while information and resources in multi-agent systems are distributed, cooperation is necessary for agents to accomplish a complex task. In the open and changeable environment on the Internet, it is of great significance to research a system flexible and capable in dynamic evolution that can find a collaboration method for agents which can be used in dynamic evolution process. With such a method, agents accomplish tasks for an overall target and at the same time, the collaborative relationship of agents can be adjusted with the change of environment. A method of task decomposition and collaboration of agents by improved contract net protocol is introduced. Finally, analysis on the result of the experiments is performed to verify the improved contract net protocol can greatly increase the efficiency of communication and collaboration in multi-agent system.

This paper presents a solution to the evolution problem of software architectures. This solution is provided by PRISMA. PRISMA is an architecture modeling approach that integrates the advantages of Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD). This integration is reflected in its model and in its Architecture Description Language (ADL). In this paper, PRISMA is presented as a framework to evolve aspect-oriented and component-based architectures by requirements-driven evolution. The evolution is supported by means of a meta-level and the reflexive properties of PRISMA ADL which have been implemented as a middleware. In addition, it is demonstrated how the evolution services of the PRISMA meta-level permit the run-time evolution of software architectures using an industrial case study, the TeachMover Robot.KeywordsSoftware ArchitectureArchitectural ModelEvolution ServiceOperator ComponentInternal ViewThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The documentation of software architecture relations as a kind of traceability information is considered important to help people understand the consequences or ripple-effects of architecture evolution. Traceability information provides a basis for analysing and evaluating software evolution, and consequently, it can be used for tasks like reuse evaluation and improvement throughout the evolution of software. To date, however, none of the published empirical studies on software architecture traceability have examined the validity of these propositions. In this paper, we hypothesize that impact analysis of changes in software architecture can be more efficient when supported by traceability links. To test this hypothesis, we designed two controlled experiments that were conducted to investigate the influence of traceability links on the quantity and quality of retrieved assets during architecture evolution analysis. The results provide statistical evidence that a focus on architecture traceability significantly reduces the quantity of missing and incorrect assets, and increases the overall quality of architecture impact analysis for evolution.

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

Chapter 1 - Relating System Quality and Software Architecture: Foundations and Approaches

Increasingly, more and more software systems must make dynamic reconfiguration of their architectures at runtime to adapt to the changing conditions. The runtime verification of architecture evolution is necessary to guarantee the conformance to the specification. In this paper, we propose a runtime model checker that supports dynamic reconfiguration of software architectures taking advantage of linear temporal logic and aspect-oriented programming. The runtime model checker is a concurrent thread with the execution thread of the dynamic software, and is an automaton which can accept exactly the set of executions that satisfy the given specification defined by LTL. So the proposed runtime model checker can monitor and verify the architecture evolution of a dynamic software system continuously at runtime.