Zhouyang Jia

Zhouyang Jia


Research Focus & Metrics

Academic Career Length

9Years (2018-Present)

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

Representative Publications

View All Publications
24 September 2018 in IEEE Transactions on Reliability
Verified
Journal Article
Closed access
SLShanshan Li
Shanshan Li
WLWang Li
Wang Li
XLXiangke Liao
Xiangke Liao
XZXiaoyu Zhang
Xiaoyu Zhang
SZShulin Zhou
Shulin Zhou
TWTeng Wang
Teng Wang
In recent years, misconfigurations have become one of the major causes of software system failures, resulting in numerous service outages. What is worse, misconfigurations are also costly to diagnose and troubleshoot. This remains a great challenge for sysadmins (system administrators) to detect, diagnose, or troubleshoot these misconfigurations. Unlike software bugs, misconfigurations are more vulnerable to sysadmins’ mistakes. Developers and researchers are attempting to improve system reactions to misconfigurations to ease the burden of sysadmins’ diagnoses. Such efforts would greatly benefit from the techniques that can comprehensively detect bad system reactions through injected misconfigurations. Unfortunately, few such studies have achieved the above goal in the past, primarily because they only relied on generic alterations and failed to find a way to systematically generate misconfigurations. In this paper, we study eight mature open-source and commercial software packages and summarize a fine-grained classification of option types. Based on this classification, we use Augmented Backus–Naur Form to summarize and extract syntactic and semantic constraints of each type. In order to generate comprehensive misconfigurations in the test systems, we propose misconfiguration generation methods for our constraints. We implement a tool named Configuration Vulnerability Detector (ConfVD) to conduct misconfiguration injection and further analyze the systems’ reaction abilities to various misconfigurations. We carried out comprehensive analyses upon Apache Httpd, MySQL, PostgreSQL, and Yum. The results of our analysis show that our option classification covers 96% of 1582 options from the above-mentioned systems. Our constraints are more fine grained than previous works and their accuracy was found to be 91% (ascertained by manual verification). Our technique could improve generic alteration approaches without constraints, and we found that ConfVD could find nearly three times the bad reactions that were found by ConfErr. In total, we found 65 bad reactions from the systems being tested and our fine-grained constraints contributed 27.7% more bad reactions than techniques only using coarse-grained constraints.

9 September 2019 in Empirical Software Engineering
Verified
Journal Article
Closed access
PDF file
SLShanshan Li
Shanshan Li
XNXu Niu
Xu Niu
ZJZhouyang Jia
Zhouyang Jia
XLXiangke Liao
Xiangke Liao
JWJi Wang
Ji Wang
TLTao Li
Tao Li

14 April 2024
Verified
Conference Paper
Open access
YFYing Fu
Ying Fu
TWTeng Wang
Teng Wang
SLShanshan Li
Shanshan Li
JDJinyan Ding
Jinyan Ding
SZShulin Zhou
Shulin Zhou
XLXiangke Liao
Xiangke Liao
Bug reproduction stands as a pivotal phase in software development, but the absence of configuration information emerges as the main obstacle to effective bug reproduction. Since configuration options generally control critical branches of the software, many bugs can only be triggered under specific configuration settings. We refer to these bugs as configuration-triggered bugs or CTBugs for short. The reproduction of CTBugs consumes considerable time and manual efforts due to the challenges in deducing the missing configuration options within the vast search space of configurations. This complexity contributes to a form of technical debt in software development. To address these challenges, we first conducted an empirical study on 120 CTBugs from 4 widely used systems to understand the root causes and factors influencing the reproduction of CTBugs. Based on our study, we designed and implemented MissConf, the first LLM-enhanced automated tool for CTBug reproduction. Miss-Conf first leverages the LLM to infer whether crucial configuration options are missing in the bug report. Once a suspect CTBug is found, MissConf employs configuration taint analysis and dynamic monitoring methods to filter suspicious configuration options set. Furthermore, it adopts a heuristic strategy for identifying crucial configuration options and their corresponding values. We evaluated MissConf on 5 real-world software systems. The experimental results demonstrate that MissConf successfully infers the 84% (41/49) of the CTBugs and reproduces the 65% (32/49) CTBugs. In the reproduction phase, MissConf eliminates up to 76% of irrelevant configurations, offering significant time savings for developers.

21 August 2019 in IEEE Access
Verified
Journal Article
Open access
SLShanshan Li
Shanshan Li
ZJZhouyang Jia
Zhouyang Jia
YLYunfeng Li
Yunfeng Li
XLXiangke Liao
Xiangke Liao
EXErci Xu
Erci Xu
LGLong Gao
Long Gao
Detecting performance bottlenecks is critical to fix software performance issues. A great part of performance bottlenecks are related to resource usages, which can be affected by configurations. To detect configuration-related performance bottlenecks, the existing works either use learning methods to model the relationships between performance and configurations, or use profiling methods to monitor the execution time. The learning methods are time-consuming when analyzing software with large amounts of configurations, while the profiling methods can incur excessive overheads. In this paper, we conduct empirical studies on configurations, performance and resources. We find that 1) 49% performance issues can be improved or fixed by configurations; 2) 71% configurations affect the performance by tuning resource usage in a simple way; and 3) four types of resources contribute the main causes of performance issues. Inspired by these findings, we design PBHunter, a resource-guided instrumentation tool to detect configuration-related performance bottlenecks. PBHunter ranks configurations by resource usage and selects the ones that heavily affect resource usages. Guided by selected configurations, PBHunter applies the code instrumentation technique in resource-related code snippets. The evaluation shows PBHunter can effectively (36/50) expose the culprits of performance issues with minor overheads (5.1%on average).

12 July 2024 in Proceedings of the ACM on Software Engineering
Verified
Journal Article
Open access
HLHaoran Liu
Haoran Liu
ZJZhouyang Jia
Zhouyang Jia
SLShanshan Li
Shanshan Li
YLYan Lei
Yan Lei
YYYue Yu
Yue Yu
XLXiangke Liao
Xiangke Liao
Error-handling bugs are prevalent in software systems and can result in severe consequences. Existing works on error-handling bug detection can be categorized into template-based and learning-based approaches. The former requires much human effort and is difficult to accommodate the software evolution. The latter usually focuses on errors of API and assumes that error handling should be right after the handled error. Such an assumption, however, may affect both learning and detecting phases. The existing learning-based approaches can be regarded as API-oriented, which starts from an API and learns if the API requires error handling. In this paper, we propose EH-Digger, an ERROR-oriented approach, which starts from an error handling. Our approach can learn why the error occurs and when the error has to be handled. We conduct a comprehensive study on 2,322 error-handling code snippets from 22 widely used software systems across 8 software domains to reveal the limitation of existing approaches and guide the design of EH-Digger. We evaluated EH-Digger on the Linux Kernel and 11 open-source applications. It detected 53 new bugs confirmed by the developers and 71 historical bugs fixed in the latest versions. We also compared EH-Digger with three state-of-the-art approaches, 30.1% of bugs detected by EH-Digger cannot be detected by the existing approaches.

27 October 2024
Verified
Conference Paper
Open access
YXYifan Xie
Yifan Xie
ZJZhouyang Jia
Zhouyang Jia
SLShanshan Li
Shanshan Li
YWYing Wang
Ying Wang
JMJun Ma
Jun Ma
XLXiangke Liao
Xiangke Liao
Many programming languages and operating system communities maintain software repositories to build their own ecosystems. The repositories often provide management tools to help users using the packages. The tools are often, if not all the times, well-designed to handle intra-repository dependencies without considering inter-repository dependencies. The users, however, often need packages from different repositories, and thus may suffer from compatibility issues. We refer to these issues as Cross-repository Compatibility (CC) issues. Existing works typically focus on a single software repository and are insufficient to detect CC issues. To fill this gap, we use both Python and Ubuntu repositories as representatives to study the root cause of CC issues, then summarize their triggering patterns and failure symptoms. Guided by the above analysis, we design Hera, an automatic tool to solve CC issues. Hera first builds a cross-repository compatibility database offline, and then online predicts, detects and fixes CC issues in the user's system environment. In our evaluation, we construct a dataset of 1,692 real-world CC issues, and Hera can detect 3,689 issues with the precision of 90.5% and the recall of 93.7%. We also collected 27 real-world CC issues from GitHub and Stack Overflow, and reproduced 26 of them. Hera can detect all the 26 cases, and provide accurate reasons as well as fixing advice.