Latest Research

Article  |  2022-04-27

Advanced Antennas Push Forward Wireless Connectivity

Kwai Man Luk ,   Baoyan Duan  

Editorial  |  2022-05-20

Intelligent analysis for software data: research and applications

Over the last few decades, software has been one of the primary drivers of economic growth in the world. Human life depends on reliable software; therefore, the software production process (i.e., software design, development, testing, and maintenance) becomes one of the most important factors to ensure the quality of software. During the production process, large amounts of software data (e.g., source code, bug reports, logs, and user reviews) are generated.With the increase in the complexity of software, how to use software data to improve the performance and efficiency of software production has become a challenge for software developers and researchers. To address this challenge, researchers have used information retrieval, data mining, and machine learning technologies to implement a series of automated tools to improve the efficiency of some important software engineering tasks, such as code search, code summarization, severity/priority prediction, bug localization, and program repair. However, these traditional approaches cannot deeply capture the semantic relations of contextual information and usually ignore the structural information of source code. Therefore, there is still room to improve the performance of these automated software engineering tasks.The word “intelligent” means that we can use a new generation of artificial intelligence (AI) technologies (e.g., deep learning) to design a series of “smart” automated tools to improve the effectiveness and efficiency of software engineering tasks so that developers’ workloads are dramatically reduced.Currently, advancement has been achieved by a new generation of AI approaches, which are well suited to address software engineering problems. We show two classical and popular automated software engineering tasks using “intelligent” analysis technology for software data as follows:1. Intelligent software developmentCode search and summarization can help developers develop quality software and improve efficiency. Code search is a frequent activity in software development that can help developers find suitable code snippets to complete software projects. Developers usually input the descriptions of these snippets as queries to achieve this purpose. However, it is extremely challenging to design a practically useful code search tool. The previous information retrieval based approaches ignored the semantic relationship between the high-level descriptions expressed by natural language and low-level source code, which affects the performance of code search. Different from information retrieval based methods, deep learning technologies can automatically learn feature representations and build mapping relationships between inputs and outputs. Therefore, the performance of code search is improved. Code summarization is the task of automatically generating natural language descriptions of source code, which can help developers understand and maintain software. In traditional automated code summarization work, researchers tend to use the summary template to extract keywords of source code, which ignores the grammar information of source code. At present, neural network technology has developed vigorously. Convolutional neural networks (CNNs), recurrent neural networks (RNNs), transformers, and other deep learning networks are applied to the task of automated code summarization.2. Intelligent software maintenanceSeverity/Priority prediction can automatically recommend appropriate labels to help developers reduce the workload for labeling severity and priority levels, which are the important features of bug reports. Severity shows the serious levels of the reported bugs, while priority indicates which bugs should be first fixed. The prediction task can help developers quickly assign the important bugs to appropriate developers for fixing them so that the efficiency of software maintenance is improved. Traditional approaches usually adopt machine learning technologies such as support vector machine (SVM) and naive Bayes (NB) to predict the severity/priority level. However, these approaches cannot overcome the problem of data imbalance, so the prediction accuracy is not perfect. Some deep learning technologies, such as CNNs and graph convolutional networks (GCNs), can effectively resolve this problem and capture the contextual semantic information of bug reports so that the prediction performance is improved.In this context, we organize a special feature in the journal on intelligent analysis for software data. This special feature covers software architecture recovery, app review analysis, integration testing, software project management, defect prediction, and method rename, as well as related applications. After a rigorous review process, six papers were selected.

Tao ZHANG ,   Xiaobing SUN   et al.

Research Article  |  2022-05-20

An incremental software architecture recovery technique driven by code changes

It is difficult to keep software architecture up to date with s during . Inconsistency is caused by the limitations of standard development specifications and human power resources, which may impact software maintenance. To solve this problem, we propose an incremental software (ISAR) technique. Our technique obtains dependency information from changed code blocks and identifies different strength-level dependencies. Then, we use double classifiers to recover the architecture based on the method of mapping code-level changes to architecture-level updates. ISAR is evaluated on 10 open-source projects, and the results show that it performs more effectively and efficiently than the compared techniques. We also find that the impact of low-quality architectural documentation on effectiveness remains stable during .

Li WANG ,   Xianglong KONG   et al.

Research Article  |  2022-05-20

Emerging topic identification from app reviews via adaptive online biterm topic modeling

Emerging topics in highlight the topics (e.g., software bugs) with which users are concerned during certain periods. Identifying emerging topics accurately, and in a timely manner, could help developers more effectively update apps. Methods for identifying emerging topics in based on s or clustering methods have been proposed in the literature. However, the accuracy of is reduced because reviews are short in length and offer limited information. To solve this problem, an improved (IETI) approach is proposed in this work. Specifically, we adopt techniques to reduce noisy data, and identify emerging topics in using the adaptive online biterm . Then we interpret the implicature of emerging topics through relevant phrases and sentences. We adopt the official app changelogs as ground truth, and evaluate IETI in six common apps. The experimental results indicate that IETI is more accurate than the baseline in identifying emerging topics, with improvements in the F1 score of 0.126 for phrase labels and 0.061 for sentence labels. Finally, we release the codes of IETI on Github (

Wan ZHOU ,   Yong WANG   et al.

Research Article  |  2022-05-20

Devising optimal integration test orders using cost–benefit analysis

Integration testing is an integral part of software testing. Prior studies have focused on reducing test cost in generation. However, there are no studies concerning the testing priorities of critical classes when generating s. Such priorities greatly affect testing efficiency. In this study, we propose an effective strategy that considers both test cost and efficiency when generating test orders. According to a series of dynamic execution scenarios, the software is mapped into a multi-layer dynamic execution network (MDEN) model. By analyzing the dynamic structural complexity, an evaluation scheme is proposed to quantify the class testing priority with the defined class risk index. ; is used to perform cycle-breaking operations, satisfying two principles: assigning higher priorities to higher-risk classes and minimizing the total complexity of test stubs. We also present a strategy to evaluate the effectiveness of algorithms by calculating the reduction of software risk during their testing process. Experiment results show that our approach performs better across software of different scales, in comparison with the existing algorithms that aim only to minimize test cost. Finally, we implement a tool, ITOsolution, to help practitioners automatically generate test orders.

Fanyi MENG ,   Ying WANG   et al.