Software Architecture Recovery Research Articles

A Framework and Taxonomy for Characterizing the Applicability of Software Architecture Recovery Approaches: A Tertiary‐Mapping Study

SummarySoftware architecture assists developers in addressing non‐functional requirements and in maintaining, debugging, and upgrading their software systems. Consequently, consistency between the designed architecture and the implemented software system itself is important; without this consistency the non‐functional requirements targeted may not be addressed and architectural documentation may mis‐direct maintenance efforts that target the associated code‐base. But often, when software is initially implemented or subsequently evolved, the designed architecture and software architecture become inconsistent, with the implemented structure degraded due to issues like developer time‐pressures, or ambiguous communication of the designed architecture. In such cases, Software Architecture Recovery (SAR) or consistency approaches can be applied to reconstruct the architecture of the software system and possibly to compare it to/re‐align it with the designed architecture. Many SAR approaches have been proposed in the research. However, choosing an appropriate architecture recovery approach for software systems is still an open issue. Consequently, this research aims to conduct a tertiary‐mapping study based on available secondary studies of architecture recovery approaches, to uncover important characteristics, towards the selection of appropriate SAR approaches. This research has aggregated 13 secondary studies and 10 primary studies beyond 2020 from 5 databases and, in doing so, identified 111 architecture recovery approaches. Based on these approaches, a taxonomy, containing nine main SAR‐selection categories is proposed and a framework (in the form of a supporting tool to help developers select an appropriate SAR approach) has been developed. Finally, this research identifies six potential open research gaps related to the underlying research that could be helpful for guiding research in the future.

Context-Aware Expert for Software Architecture Recovery (CAESAR): An automated approach for recovering software architectures

Software architecture recovery approaches help to reconstruct the architecture of complex software systems. However, the manual effort and expertise required to use such techniques are high, as the user demands detailed knowledge about software architecture recovery process and preparing additional software artifacts to use as input for such approaches. Such practices lack consideration for the context standards of the recovered software. Additionally, proper module detection rules that are aware of the modeled system’s context should be studied to enhance the cluster quality of the detected modules. We introduce a novel approach to software architecture recovery by implementing an automated knowledge-based rules solution that considers the context of the developed software while identifying and clustering that system’s software modules. Such solution is aided by a novel code distance model that is utilized to enhance the cohesiveness of the recovered software modules, improving the recovered software architecture quality, and enhancing readability through providing visualizations at different abstraction levels for the recovered architecture. The proposed method has been evaluated on two software systems with varying sizes and from different contexts and involved experienced participants. The results demonstrate significant improvements in cohesion and coupling of the produced clusters compared to alternative architecture recovery approaches.

Genetic algorithms and heuristics hybridized for software architecture recovery

Genetic algorithms and heuristics hybridized for software architecture recovery

代码变更驱动的增量式软件架构恢复技术

代码变更驱动的增量式软件架构恢复技术

Software Architecture Recovery Using Integrated Dependencies Based on Structural, Semantic, and Directory Information

Architecture recovery techniques study dependencies in source code and reconstruct architecture. Most techniques either use structural or semantic dependencies and it is observed that the use of directory information helps in improving architecture recovery. The research carried out to date has focused on using the semantic information in a very limited manner, and directory information in a trivial manner without considering directory hierarchy. Further, all three (structural, semantic, and directory-structure) are reported to be very useful in architecture recovery but have not been used in a combined manner at all. So, this paper proposes a new scheme for architecture recovery using a weighted combination of all three dependencies. A new approach is designed to effectively mine semantic dependencies and extract directory dependencies. Finally, different dependency schemes are evaluated with four clustering algorithms on three open-source projects. The obtained results show that the proposed scheme performs better than the existing approaches in architecture recovery.

Ensemble clustering based approach for software architecture recovery

Ensemble clustering based approach for software architecture recovery

A particle swarm optimization approach for large-scale many-objective software architecture recovery

The software systems with a well-documented architecture are easy to understand and evolve. However, in most cases, either the documented architecture is unavailable or get eroded badly. In these cases, to understand and evolve the software systems, developers often need to recover the architectural components from the system implementation code. Recently, a variety of heuristic-based multi-objective optimization algorithms (MoOAs) for software architecture recovery (SAR) have been introduced. Most of the existing SAR approaches are designed by adopting the traditional MoOAs. However, the performance of such approaches degrades drastically with large-scale many-objective SAR (LSMaO-SAR). To address the challenges the MoOAs caused by the LSMaO-SAR, we introduce a large-scale many-objective particle swarm optimization (LSM-PSO) by customizing the framework of the PSO algorithm. For this, we adopt various strategies such as Balance Fitness Evaluation (BFE), Quality Indicator (QI) based fitness evaluation, Fuzzy-Pareto dominance (FPD), and Two-archive external storage, and incorporate into the PSO model. To test the effectiveness of the LSM-PSO, it is applied over five software projects and compared with the existing SAR approaches. The results show that the proposed LSM-PSO outperforms the existing optimization-based SAR approaches.

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.

A systematic methodology to migrate complex real-time software systems to multi-core platforms

This paper proposes a systematic three-stage methodology for migrating complex real-time industrial software systems from single-core to multi-core computing platforms. Single-core platforms have limited computational capabilities that prevent integration of computationally demanding applications such as image processing within the existing system. Modern multi-core processors offer a promising solution to address these limitations by providing increased computational power and allowing parallel execution of different applications within the system. However, the transition from traditional single-core to contemporary multi-core computing platforms is non-trivial and requires a systematic and well-defined migration process. This paper reviews some of the existing migration methods and provides a systematic multi-phase migration process with emphasis on software architecture recovery and transformation to explicitly address the timing and dependability attributes expected of industrial software systems. The methodology was evaluated using a survey-based approach and the results indicate that the presented methodology is feasible, useable and useful for real-time industrial software systems.

Systematic review on next-generation web-based software architecture clustering models

Software architecture is the heart of web-based software systems determining its components and their connections. These days, fast release and quick delivery of next-generation software, which is the primary goal of the software industry, triggers an occurring error in the software development process. Therefore, recovery and metric measurement techniques are essential tools to assess the quality and soundness of web-based software architecture and return the system to the earlier or original stable state. Reusability techniques could be used to decrease the time, effort, and cost of software development as well. Clustering is a commonly used data mining technique employed to achieve these goals. Therefore, this paper as a first survey presents a literature review for web-based software architecture clustering models that are categorized into software architecture recovery, software architecture metric measurement, and software architecture reusability. Most of the papers studied in this literature were published in 2017 and 2018. IEEE publication has the highest published papers. We classified 67 selected research studies in 3 classes where 42% of them were considered as software architecture recovery methods, 39% of them were reported for software architecture metric measurement methods, and 19% of them were considered for software architecture reusability methods.

Software Architecture Recovery Techniques

There are many software architecture recovery techniques which has been discovered which automatically recover software architecture from the software implementation. In this project we will propose a research approach for comparing different software architecture recovery techniques. A dependency (code dependency) is a file that something you are trying to install requires. It can be a library of a third-party organization. These dependencies effect the application but it is very hard to makeany software without using these external dependencies. But these code dependencies have some disadvantages too. Firstly, we will specify about the code dependencies and their impact on software design. Then we will describe some software architecture recovery techniques. We will take a project (Bash) as our research base and we will apply these recovery techniques to the project. We will use some software testing tools to compare these algorithms (software recovery techniques) with each project.

Identifying Semantic Outliers of Source Code Artifacts and Their Application to Software Architecture Recovery

Understanding software architecture is essential to software maintenance. There has been much effort to derive software architecture views from source code artifacts. Typically, along with structural information, the semantic information derived from an identifier name and comments are helpful. However, because code vocabulary choice depends on a developer’s subjective decision, some source code may have semantically low text quality, leading to an inaccurate architecture recovery. This paper aims to improve the architecture recovery of a software system by identifying and removing the semantic outliers of source code artifacts. Accordingly, we propose a novel measure Conceptual Conformity (CC), which computes the similarity between two latent topic distributions obtained from both the source code and its package. We use CC to identify source code that is not relevant to the package’s semantic context and define it as a semantic outlier. Because the semantic outliers may cause inaccurate architecture recovery, we remove them during the recovery process. We apply our approach to three open-source projects. The results demonstrate that, for projects with low recovery performance, removing outliers leads to higher recovery accuracy.

Software Architecture Module-View Recovery Using Cluster Ensembles

Software architecture documents are valuable assets supporting the maintenance process for software systems. Unfortunately, in many projects, software architecture documentation is not conducted properly or the documents become obsolete due to a discrepancy with the current architecture. To address this, various automated methods to recover software architecture have been proposed in the literature. We argue that most previous studies have not considered cluster ensembles but relied on a single clustering algorithm. In this paper, we propose to take advantage of cluster ensembles for software architecture recovery. Our experiments on five open-source projects are reported and the results are analyzed.

The WGB method to recover implemented architectural rules

Context: The identification of architectural rules, which specify allowed dependencies among architectural modules, is a key challenge in software architecture recovery. Existing approaches either retrieve a large set of rules, compromising their practical use, or are limited to supporting the understanding of such rules, which are manually recovered.Objective: To propose and evaluate a method to recover architectural rules, focusing on those implemented in the source code, which may differ from planned or conceptual rules.Method: We propose the WGB method, which analyzes dependencies among architectural modules as a graph, adding weights that correspond to the proposed module dependency strength (MDS) metric and identifies the set of implemented architectural rules by solving a mathematical optimization problem. We evaluated our method with a case study and an empirical study that compared rules extracted by the method with the conceptual architecture and source code dependencies of six systems. These comparisons considered efficiency and effectiveness of our method.Results: Regarding efficiency, our method took 45.55 s to analyze the largest system evaluated. Considering effectiveness, our method captured package dependencies as extracted rules with a reduction of 87.6%, on average, to represent this information. Using allowed architectural dependencies as a reference point (but not a gold standard), provided rules achieved 37.1% of precision and 37.8% of recall.Conclusion: Our empirical evaluation shows that the implemented architectural rules recovered by our method consist of abstract representations of (a large number of) module dependencies, providing a concise view of dependencies that can be inspected by developers to identify occurrences of architectural violations and undocumented rules.

A Methodological Approach for Software Architecture Recovery

Background/Objectives: The software architecture recovery process is an activity that is included in different contexts. However, the methodological proposals to perform this process do not take into account the particular needs of the context in which it is developed. The objective of this work is to propose a methodology for Software Architecture Recovery, responding the specific needs of the context in which the need to recover the architecture of a software product is presented. Methods: The model was obtained after applying the pattern-matching technique in order to establish the common aspects to all the proposals identified in the literature review. Findings: The results of the evaluation of the methodological proposal reveal the usefulness when recovering architectures, since it allows focusing attention on the most relevant aspects of recovery for the specific context in which the process is performed. Novelty: The defined methodological proposal is a new way of performing architecture recovery processes, which achieves more relevant results to the context in which the needs arise. Keywords: Architecture Recovery, Methodological Approach, Reverse Engineering, Software Architecture

Directory-Based Dependency Processing for Software Architecture Recovery

3Directory structure contains a wealth of software design information; it is used to transfer thoughts of architects to developers. Information extracted from directory paths should play an important role in architecture recovery techniques, but it has been proved that modules or components directly represented by directories are not accurate due to the inconsistency between stages of development and design. To make better use of information extracted from directories, we propose a directory-based dependency processing technique to utilize the information of directories in the process of structure-based architecture recovery. The technique groups the selected inter-coupling files and intra-coupling files in the same directory into a submodule and generates submodule-level dependency graph based on file-level dependency graph. We apply both manual and automatic architecture recovery techniques on submodule-level dependency graph, and the results show that our technique can greatly improve the efficiency and effectiveness of manual and automatic architecture recovery techniques; the technique can also make other structure-based recovery techniques easily scalable to large-sized projects.

Подход к анализу исполняемого кода на основе восстановления программной архитектуры

The article discusses a new approach to obtaining additional information about the software module under study based on the preliminary software architecture recovery during the executable code analysis. As a result, it is possible to reduce the requirements for the resources spent by limiting the field of research, rational choice of priorities, and abstraction from secondary elements. The paper demonstrates the feasibility of restoring the software architecture in a two-step process: first, the separate components are isolated, and then their purposes and relationships are determined. An automated method for decomposing a software module is proposed, which allows allocating components corresponding to static libraries, classes, and their groups. This method is based on the functions clustering by the distances between them in the address space and on the call graph. A description of the implementation of the developed method as a plug-in for the IDA disassembler is given.

General methods for software architecture recovery: a potential approach and its evaluation

Software architecture is a critical artefact in the software lifecycle. It is a system blueprint for construction, it aids in planning teaming and division of work, and it aids in reasoning about system properties. But architecture documentation is seldom created and, even when it is initially created, it is seldom maintained. For these reasons organisations often feel the need to recover legacy architectures, for example, as part of planning for evolution or cloud migration. But there is no existing general architecture recovery approach nor tool that can be applied to any type of system, under any condition. We will show that one way of achieving such generality is to apply systematic code inspection following a Grounded Theory (GT) approach. Though relatively costly and human-intensive, a GT-based approach has several merits, for example: (a) it is general by design; (b) it can be partially automated; (c) it yields evidence-based results rooted of the system being examined. This article presents one theoretical formulation of a general architecture recovery method–called REM–and reports on the evaluation of REM in the context of a large architecture recovery campaign performed for the European Space Agency. Our results illustrate some intriguing properties and opportunities of GT-based architecture recovery approaches and point out lessons learned and venues for further research.

Case study on which relations to use for clustering-based software architecture recovery

Clustering-based software architecture recovery is an area that has received significant attention in the software engineering community over the years. Its key concept is the compilation and clustering of a system-wide graph that consists of source code entities as nodes, and source code relations as edges. However, the related research has mostly focused on investigating different clustering methods and techniques, and consequently there is limited work on addressing the question of what is a minimal set of relations that can be easily extracted from the system's source code, and yet can be accurately used for extracting its architecture. In this paper, we report on results obtained from an architecture recovery case study we have conducted, by considering all possible combinations which can be generated from thirteen commonly used source code relations. We have examined the similarity of the extracted architectures obtained by using each different relation combination for different systems, against the corresponding architecture which is obtained by applying all thirteen relations and whch we consider as the ground truth architecture. For this purpose, we have also examined whether the use of all these thirteen relations is indeed adequate to yield a ground truth architecture, by applying this architecture extraction process on five large sofware systems for which their ground truth architecture has been independently established. The overall results of our study indicate that there is small set of relations for procedural systems, and another similar set for object oriented systems, that can be easily extracted from the source code and yet used to yield an architecture that is close to the ground truth architecture.

Supervised Learning For Orphan Adoption Problem In Software Architecture Recovery

Maintenance of architectural documentation is a prime requirement for evolving software systems. New versions of software systems are launched after making the changes that take place in a software system over time. The orphan adoption problem, which deals with the issue of accommodation of newly introduced resources (orphan resources) in appropriate subsystems in successive versions of a software system, is a significant problem. The orphan adoption algorithm has been developed to address this problem. For evolving software systems, it would be useful to recover the architecture of subsequent versions of a software system by using existing architectural information. In this paper, we explore supervised learning techniques (classifiers) for recovering the architecture of subsequent versions of a software system by taking benefit of existing architectural information. We use three classifiers, i.e., Bayesian classifier, k-Nearest Neighbor classifier and Neural Network for orphan adoption. We conduct experiments to compare the performance of the classifiers using various dependencies between entities in a software system. Our experiments highlight correspondence between the orphan adoption algorithm and the classifiers, and also reveal their strengths and weaknesses. To combine strengths of individual classifiers, we propose using a multiclassifier approach in which classifiers work cooperatively to improve classification accuracy. Experiments show that there is significant improvement in results when our proposed multiclassifier approach is used.