Semi-automated architectural abstraction specifications for supporting software evolution

In this paper we present an approach for supporting the semi-automated architectural abstraction of architectural models throughout the software life-cycle. It addresses the problem that the design and implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architecture component and connector views from implemented systems and keeping the abstracted architecture models up-to-date during software evolution. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate architectural component views from the source code using model-driven development (MDD) techniques and check whether architectural design constraints are fulfilled by these models. Our approach supports the automatic generation of traceability links between source code elements and architectural abstractions using MDD techniques to enable software architects to easily link between components and the source code elements that realize them. It enables software architects to compare different versions of the generated architectural component view with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions of five open source systems and by analyzing the performance of our approach in these cases.     

一种基于横切特征分析的软件体系结构自动重构方法

软件体系结构中的横切关注点增加了软件体系结构的复杂性,从而加剧了体系结构演化与维护的困难.这种设计问题可以通过体系结构层面的重构来进行改善.在已有的横切特征分析方法基础上,提出了一种面向横切特征分析的体系结构自动重构方法.该方法首先基于特征与构件之间的追踪关系分析横切特征,然后将与横切特征有直接追踪关系的构件从初始体系结构中提取出来,实现方面构件,完成体系结构重构.在面向方面体系结构描述语言AO-ADL基础上开发了相应的体系结构重构工具,并针对一个业务系统进行了体系结构重构实验.实验结果表明,该方法能有效地实现体系结构横切特征的自动化重构.     

Documenting after the fact: Recovering architectural design decisions

Software architecture documentation helps people in understanding the software architecture of a system. In practice, software architectures are often documented after the fact, i.e. they are maintained or created after most of the design decisions have been made and implemented. To keep the architecture documentation up-to-date an architect needs to recover and describe these decisions.This paper presents ADDRA, an approach an architect can use for recovering architectural design decisions after the fact. ADDRA uses architectural deltas to provide the architect with clues about these design decisions. This allows the architect to systematically recover and document relevant architectural design decisions. The recovered architectural design decisions improve the documentation of the architecture, which increases traceability, communication, and general understanding of a system.     

Preserving architectural decisions through architectural patterns

Architectural decisions have emerged as a means to maintain the quality of the architecture during its evolution. One of the most important decisions made by architects are those about the design approach such as the use of patterns or styles in the architecture. The structural nature of this type of decisions give them the potential to be controlled systematically. In the literature, there are some works on the automation of architectural decision violation checking. In this paper we show that these works do not allow to detect all possible architectural decision violations. To solve this problem we propose an approach which: (i) describes architectural patterns that hold the architectural decision definition, (ii) integrates architectural decisions into an architectural model and, (iii) automates the architectural decision conformance checking. The approach is implemented using Eclipse modeling framework and its accompanying technologies. Starting from well-known architectural patterns, we show that we can formalize all those related to the structural aspect. Through two evaluations, we show that our approach can be adapted to different architecture paradigms and allows to detect more violations comparing to the existing approaches.     

Stability assessment of aspect-oriented software architectures: A quantitative study

Design of stable software architectures has increasingly been a deep challenge to software developers due to the high volatility of their concerns and respective design decisions. Architecture stability is the ability of the high-level design units to sustain their modularity properties and not succumb to modifications. Architectural aspects are new modularity units aimed at improving design stability through the modularization of otherwise crosscutting concerns. However, there is no empirical knowledge about the positive and negative influences of aspectual decompositions on architecture stability. This paper presents an exploratory analysis of the influence exerted by aspect-oriented composition mechanisms in the stability of architectural modules addressing typical crosscutting concerns, such as error handling and security. Our investigation encompassed a comparative analysis of aspectual and non-aspectual decompositions based on different architectural styles applied to an evolving multi-agent software architecture. In particular, we assessed various facets of components’ and compositions’ stability through such alternative designs of the same multi-agent system using conventional quantitative indicators. We have also investigated the key characteristics of aspectual decompositions that led to (in)stabilities being observed in the target architectural options. The evaluation focused upon a number of architecturally-relevant changes that are typically performed through real-life maintenance tasks.     

面向方面的体系结构描述语言AC2-ADL

体系结构描述语言(ADL)是基于体系结构的软件开发的基础,传统的ADL由于缺乏对混杂与分散在软件体系结构多个单元中的各种设计决策的描述能力,导致软件体系结构设计方案难以理解、难以演化和难以重用.通过设计面向方面的软件体系结构描述语言AC2-ADL,使用方面组件明确地描述系统的横切关注点;并引入方面连接件以及抽象出软件体系结构语境中的注入点,呈现结构之间复杂的交互,以解决不同关注点的分散和交织等问题,试图为设计和描述面向方面的软件系统的软件体系结构提供一种有效的解决方案.研究结合电子商务领域的网上拍卖系统,讨论了该语言的主要应用过程,具有一定的参考作用.     

基于时序逻辑的面向方面体系结构描述语言

运用传统体系结构描述语言描述的软件体系结构(SA)方案始终存在着一些横切行为和特征,它们混杂和散列在不同的SA设计单元中,使得SA难以理解、难以演化和难以重用。针对这一问题,基于时序逻辑语言XYZ/E,在统一的时序逻辑框架下设计出一种面向方面体系结构描述语言AC2-ADL。系统地阐述了AC2-ADL的概念框架并用XYZ/E进行语义解释,最后结合案例介绍了如何用AC2-ADL对SA进行描述。     

Generating CAM aspect-oriented architectures using Model-Driven Development

Aspect-Oriented Software Development promotes the separation of those concerns that cut across several components and/or are tangled with the base functionality of a component, through all phases of the software lifecycle. The benefit of identifying these crosscutting concerns (aspects) at the architectural level in particular is to improve the architecture design and its subsequent evolution, before moving onto detailed design and implementation. However, software architects are not usually experts on using specific AO architecture notations. Therefore, the aim of this paper is to provide support to define and specify aspect-oriented (AO) architectures using non-AO ones as the source. We will use the Model-Driven Development approach to transform a component-based architecture model into an AO architecture model. The CAM (component and aspect model) model and the DAOP–ADL language are the proposals used for modelling and specifying AO architectures. We will show how we automated part of the process and the tool support.     

面向方面体系结构建模研究

面向方面体系结构建模是面向方面软件开发(AOSD)的重要组成部分,也是近些年面向方面领域研究的热点问题。传统的软件体系结构设计方法没有单独地考虑横切关注点。因此,在软件体系结构设计阶段,建模人员需要新的机制来描述这些横切关注点。本文首先提出一个以横切为中心的面向方面体系结构概念框架;然后通过在体系结构设计阶段引入该框架中的核心概念,提出一种在体系结构设计阶段建模横切关注点的方法,从而支持其在早期进行横切关注点的分离。     

Towards an Integrated View on Architecture and its Evolution

Information about the evolution of a software architecture can be found in the source basis of a project and in the release history data such as modification and problem reports. Existing approaches deal with these two data sources separately and do not exploit the integration of their analyses. In this paper, we present an architecture analysis approach that provides an integration of both kinds of evolution data. The analysis applies fact extraction and generates specific directed attributed graphs; nodes represent source code entities and edges represent relationships such as accesses, includes, inherits, invokes, and coupling between certain architectural elements. The integration of data is then performed on a meta-model level to enable the generation of architectural views using binary relational algebra. These integrated architectural views show intended and unintended couplings between architectural elements, hence pointing software engineers to locations in the system that may be critical for on-going and future maintenance activities. We demonstrate our analysis approach using a large open source software system.     

一种基于面向侧面技术的并发式软件建模方法

基于面向侧面（Aspect-Oriented）技术及统一建模语言状态图提出了并发式软件系统开发过程中横切特性的建模方法。本方法将并发软件系统的业务逻辑和横切行为分别封装到复合状态的不同正交区域中，并通过事件广播机制反映二者的交互关系。同时，以模块化的状态迁移系统 （Modular Transition System）作为基本计算模型，对该建模方法进行形式化描述，给出了模型元素及建模过程的精确语义。实例研究表明，该方法在并发软件设计阶段实现了横切关注点的分离策略，并使得系统模型具有松耦合、适应性和可跟踪性的优点。     

Toward a discipline of scenario‐based architectural engineering

Software architecture analysis is a cost‐effective means of controlling risk and maintaining system quality throughout the processes of software design, development and maintenance. This paper presents a sequence of steps that maps architectural quality goals into scenarios that measure the goals, mechanisms that realize the scenarios and analytic models that measure the results. This mapping ensures that design decisions and their rationale are documented in such a fashion that they can be systematically explored, varied, and potentially traded off against each other. As systems evolve, the analytic models can be used to assess the impact of architectural changes, relative to the system's changing quality goals. Although scenarios have been extensively used in software design to understand the ways in which a system meets its operational requirements, there has been little systematic use of scenarios to support analysis, particularly analysis of a software architecture's quality attributes: modifiability, portability, extensibility, security, availability, and so forth. In this paper we present a unified approach to using scenarios to support both the design, analysis and maintenance of software architectures, and examples from large‐scale software development projects where we have applied the approach. We also present a tool, called Brie, that aids in: scenario capture, mapping scenarios to software architectures, and the association of analytic models with particular portions of architectures. The approach that we have devised, and that Brie supports, is a foundation for a discipline of architectural engineering. Architectural engineering is an iterative method of design, analysis and maintenance where design decisions are motivated by scenarios, and are supported by documented analyses.     

Real-Time Reflexion Modelling in architecture reconciliation: A multi case study

ContextReflexion Modelling is considered one of the more successful approaches to architecture reconciliation. Empirical studies strongly suggest that professional developers involved in real-life industrial projects find the information provided by variants of this approach useful and insightful, but the degree to which it resolves architecture conformance issues is still unclear.ObjectiveThis paper aims to assess the level of architecture conformance achieved by professional architects using Reflexion Modelling, and to determine how the approach could be extended to improve its suitability for this task.MethodAn in vivo, multi-case-study protocol was adopted across five software systems, from four different financial services organizations. Think-aloud, video-tape and interview data from professional architects involved in Reflexion Modelling sessions were analysed qualitatively.ResultsThis study showed that (at least) four months after the Reflexion Modelling sessions less than 50% of the architectural violations identified were removed. The majority of participants who did remove violations favoured changes to the architectural model rather than to the code. Participants seemed to work off two specific architectural templates, and interactively explored their architectural model to focus in on the causes of violations, and to assess the ramifications of potential code changes. They expressed a desire for dependency analysis beyond static-source-code analysis and scalable visualizations.ConclusionThe findings support several interesting usage-in-practice traits, previously hinted at in the literature. These include (1) the iterative analysis of systems through Reflexion models, as a precursor to possible code change or as a focusing mechanism to identify the location of architecture conformance issues, (2) the extension of the approach with respect to dependency analysis of software systems and architectural modelling templates, (3) improved visualization support and (4) the insight that identification of architectural violations in itself does not lead to their removal in the majority of instances.     

Harmonizing architectural decisions with component view models using reusable architectural knowledge transformations and constraints

Architectural design decisions (ADDs) have been used in recent years for capturing design rationale and documenting architectural knowledge (AK). However, various architectural design views still provide the most common means for describing and communicating architectural design. The evolution of software systems requires that both ADDs and architectural design views are documented and maintained, which is a tedious and time-consuming task in the long run. Also, in lack of a systematic and automated support for bridging between ADDs and architectural design views, decisions and designs tend to become inconsistent over time. In our proposal, we introduce a reusable AK transformation language for supporting the automated transformation of reusable AK knowledge to component-and-connector models, the architectural design view used most commonly today. In addition, reusable consistency checking rules verify the consistency between decisions and designs. We evaluate our approach in an industrial case study and show that it offers high reusability, provides automation, and can, in principle, deal with large numbers of recurring decisions.     

Detecting deviations in the code using architecture view-based drift analysis

ContextOne of the key requirements for the code is conformance with the architecture. Architectural drift implies the diverging of the implemented code from the architecture design of the system. Manually checking the consistency between the implemented code and architecture can be intractable and cumbersome for large-scale systems.ObjectiveThis article proposes a holistic, automated architecture drift analysis approach that explicitly focuses on the adoption of architecture views. The approach builds on, complements, and enhances existing architecture conformance analysis methods that do not adopt a holistic approach or fail to address the architecture viewpoints.MethodA model-driven development approach is adopted in which architecture views are represented as specifications of domain-specific languages. The code in its turn, is analyzed, and the architectural view specifications are reconstructed, which are then automatically checked with the corresponding architecture models.ResultsTo illustrate the approach, we have applied a systematic case study research for an architecture drift analysis of the business-to-customer (B2C) system within a large-scale software company.ConclusionThe case study research showed that divergences and absences of architectural elements could be detected in a cost-effective manner with the proposed approach.