Lu Xiao

Dr. Lu Xiao


Research Focus & Metrics

Academic Career Length

13Years (2014-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
14 April 2019 in IEEE Transactions on Software Engineering
Verified
Journal Article
Closed access
RMRan Mo
Ran Mo
YCYuanfang Cai
Yuanfang Cai
RKRick Kazman
Rick Kazman
LXLu Xiao
Lu Xiao
QFQiong Feng
Qiong Feng
In large-scale software systems, error-prone or change-prone files rarely stand alone. They are typically architecturally connected and their connections usually exhibit architecture problems causing the propagation of error-proneness or change-proneness. In this paper, we propose and empirically validate a suite of architecture anti-patterns that occur in all large-scale software systems and are involved in high maintenance costs. We define these architecture anti-patterns based on fundamental design principles and Baldwin and Clark's design rule theory. We can automatically detect these anti-patterns by analyzing a project's structural relationships and revision history. Through our analyses of 19 large-scale software projects, we demonstrate that these architecture anti-patterns have significant impact on files' bug-proneness and change-proneness. In particular, we show that 1) files involved in these architecture anti-patterns are more error-prone and change-prone; 2) the more anti-patterns a file is involved in, the more error-prone and change-prone it is; and 3) while all of our defined architecture anti-patterns contribute to file's error-proneness and change-proneness, Unstable Interface and Crossing contribute the most by far.

31 May 2014
Verified
Conference Paper
Open access
PDF file
LXLu Xiao
Lu Xiao
YCYuanfang Cai
Yuanfang Cai
RKRick Kazman
Rick Kazman
In this paper, we investigate software architecture as a set of overlapping design rule spaces, formed by one or more structural or evolutionary relationships and clustered using our design rule hierarchy algorithm. Considering evolutionary coupling as a special type of relationship, we investigated (1) whether design rule spaces can reveal structural relations among error-prone files; (2) whether design rule spaces can reveal structural problems contributing to error-proneness.We studied three large-scale open source projects and found that error-prone files can be captured by just a few design rule sub-spaces. Supported by our tool, Titan, we are able to flexibly visualize design rule spaces formed by different types of relationships, including evolutionary dependencies. This way, we are not only able to visualize which error-prone files belong to which design rule spaces, but also to visualize the structural problems that give insight into why these files are error prone. Design rule spaces provide valuable direction on which parts of the architecture are problematic, and on why, when, and how to refactor.

5 August 2021 in IEEE Transactions on Software Engineering
Verified
Journal Article
Closed access
LXLu Xiao
Lu Xiao
YCYuanfang Cai
Yuanfang Cai
RKRick Kazman
Rick Kazman
RMRan Mo
Ran Mo
QFQiong Feng
Qiong Feng
Architectural Technical Debt ( ATD ) refers to sub-optimal architectural design in a software system that incurs high maintenance “interest” over time. Previous research revealed that ATD has significant negative impact on daily development. This paper contributes an approach to enable an architect to precisely locate ATDs , as well as capture the trajectory of maintenance cost on each debt, based on which, predict the cost of the debt in a future release. The ATDs are expressed in four typical patterns, which entail the core of each debt. Furthermore, we aggregate compound ATDs to capture the complicated relationship among multiple ATD instances, which should be examined together for effective refactoring solutions. We evaluate our approach on 18 real-world projects. We identified ATDs that persistently incur significant (up to 95 percent of) maintenance costs in most projects. The maintenance costs on the majority of debts fit into a linear regression model—indicating stable “interest” rate. In five projects, 12.1 to 27.6 percent of debts fit into an exponential model, indicating increasing “interest” rate, which deserve higher priority from architects. The regression models can accurately predict the costs of the majority of (82 to 100 percent) debts in the next release of a system. By aggregating related ATDs , architects can focus on a small number of cost-effective compound debts, which contain a relatively small number of source files, but account for a large portion of maintenance costs in their projects. With these capabilities, our approach can help architects make informed decisions regarding whether, where, and how to refactor for eliminating ATDs in their systems.

24 January 2018 in IEEE Transactions on Software Engineering
Verified
Journal Article
Closed access
YCYuanfang Cai
Yuanfang Cai
LXLu Xiao
Lu Xiao
RKRick Kazman
Rick Kazman
RMRan Mo
Ran Mo
QFQiong Feng
Qiong Feng
In this paper, we propose an architecture model called Design Rule Space (DRSpace). We model the architecture of a software system as multiple overlapping DRSpaces, reflecting the fact that any complex software system must contain multiple aspects, features, patterns, etc. We show that this model provides new ways to analyze software quality. In particular, we introduce an Architecture Root detection algorithm that captures DRSpaces containing large numbers of a project's bug-prone files, which are called Architecture Roots (ArchRoots). After investigating ArchRoots calculated from 15 open source projects, the following observations become clear: from 35% to 91% of a project's most bug-prone files can be captured by just 5 ArchRoots, meaning that bug-prone files are likely to be architecturally connected. Furthermore, these ArchRoots tend to live in the system for significant periods of time, serving as the major source of bug-proneness and high maintainability costs. Moreover, each ArchRoot reveals multiple architectural flaws that propagate bugs among files and this will incur high maintenance costs over time. The implication of our study is that the quality, in terms of bug-proneness, of a large, complex software project cannot be fundamentally improved without first fixing its architectural flaws.

14 April 2022 in IEEE Transactions on Software Engineering
Verified
Journal Article
Closed access
YZYutong Zhao
Yutong Zhao
LXLu Xiao
Lu Xiao
ABAndre B. Bondi
Andre B. Bondi
BCBihuan Chen
Bihuan Chen
YLYang Liu
Yang Liu
Software performance is a critical quality attribute that determines the success of a software system. However, practitioners lack comprehensive and holistic understanding of how real-life performance issues are caused and resolved in practice from the technical, engineering, and economic perspectives. This paper presents a large-scale empirical study of 570 real-life performance issues from 13 open source projects from various problem domains, and implemented in three popular programming languages, Java (192 issues), C/C++ (162 issues), and Python (216 issues). From the technical perspective, we summarize eight general types of performance issues with corresponding root causes and resolutions that apply for all three languages. We also identify available tools for detecting and resolving different types of issues from the literature. In addition, we found that 27% of the 570 issues are resolved by design-level optimizationcoordinated revision of a group of related source files and their design structure. We reveal four typical design-level optimization patterns, including classic design patterns, change propagation, optimization clone, and parallel optimization that practitioners should be aware of in resolving performance issues. From the engineering perspective, this study analyzes how test code changes in performance optimization. We found that only 15% of the 570 performance issues involve revision of test code. In most cases, the revised test cases focus on the functional logic of the performance optimization, rather than directly evaluate the performance improvement. This finding points to the potential lack of engineering standard for formally verifying performance optimization in regression testing. Finally, from the economic perspective, we analyze the Return On Investment of performance optimization. We found that design-level optimization usually requires more investment, but not always yields to higher performance improvement. However, developers tend to use design-level optimization when they concern about other quality attributes, such as maintainability and readability.

23 April 2024 in IEEE Open Journal of Systems Engineering
Verified
Journal Article
Open access
Farah ElkourdiFarah Elkourdi
Farah Elkourdi
CWChenhao Wei
Chenhao Wei
LXLu Xiao
Lu Xiao
ZYZhongyuan Yu
Zhongyuan Yu
OAOnur Asan
Onur Asan
Healthcare systems and applications are increasingly used to improve patient care. However, these applications face data security, privacy, and regulatory compliance challenges. The health insurance portability and accountability act (HIPAA) regulates the use and disclosure of patient health information. Ensuring HIPAA compliance in the software engineering process poses critical challenges to software engineering practitioners. This review focuses on understanding the state-of-the-art in the current literature for ensuring HIPAA compliance in the software development life cycle, namely, requirement gathering, software design, implementation, software testing, and evolution. The findings of this study shed light on software engineers in creating HIPAA compliance healthcare systems and applications. This literature review presents the key themes and trends in this research area. Also, it provides recommendations for future research in the intersection of software engineering methods and HIPAA compliance.