Mobile apps are ubiquitous, and have become an indispensable part of our daily life. It is crucial to ensure the correctness, security and performance of these apps through automated GUI modeling. UI Transition Graph (UTG) is an important way of app abstract and modeling. While there have been considerable research efforts on constructing UTG through static or dynamic analysis, obtaining a relatively accurate and complete UTG is challenging. To this end, we present an approach and tool RLDroid that synergistically combines static analysis, dynamic exploration and reinforcement learning techniques to construct UTGs for Android apps. Specifically, RLDroid first extracts a seed UTG through static analysis, and uses this UTG with a depth-first strategy to guide the dynamic exploration. Then, RLDroid provides a Q-learning-based strategy initialized with the generated partial UTG to enhance dynamic exploration and outputs the final UTG. Our experiments on 29 Android apps show that RLDroid identified a total of 871 nodes (i.e., UI pages) and 2726 edges (i.e., transitions) without any false positives, which significantly outperforms the state-of-the-art GUI modeling techniques. Our two exploration strategies, the seed-UTGguided exploration and the Q-learning-enhanced exploration, make positive contributions to improving the completeness of UTG. Furthermore, the UTGs generated by RLDroid are highly useful for automated GUI testing, resulting in a 60 % increase in code coverage and the discovery of 52 additional crashes.

Background: Changes on source code may propagate to distant code entities through various relationships, making related changes obligatory. Identifying change impacts is challenging due to the complexity of how changes spread. Although association rules are widely used for change impact prediction, they rely solely on historical co-changes, which limits their accuracy when entities rarely or never co-change. Aims: This study explores the integration of evolutionary coupling with software change relationships among changed code entities to enhance the state-of-the-art association rule mining technique, TARMAQ. Method: We integrate evolutionary coupling with 12 types of software change relationships, such as structural dependencies and code clones, to better capture associated changes. Results: Analyzing thousands of commits from six open-source systems, we observed: (1) Incorporating software change relationship analysis significantly improves TARMAQ’s prediction recall and mean average precision (MAP), (2) The top-5 predictions exhibit notable increasing in precision, recall, F1-score, and MAP, and (3) Based on our implementation, the integrated method is practically applicable. Conclusions: Combining evolutionary coupling and software change relationships can improve the recall and prioritization of impact predictions in association rule-based techniques.

Changes on source code may propagate to distant code entities through various kinds of relationships, which may form up change propagation channels . It is however difficult for developers to reveal code change propagate channels due to sophisticated interrelationships among code entities. In this work, we propose a novel graph representation for the changed code entities and related code entities changed within a range of space and time so that the types of relationships along which the changes are propagated can be explicitly presented. Then a subgraph mining technique is used to find the frequent change propagation channels . We finally reveal 40 types of frequent change propagation channels that cover over 98% cases of code change propagation in five well-known open-source Java projects. We find evidence that the code changes propagated through an unchanged intermediate code entity consume more time than those through a changed one, indicating the difficulties in maintaining code entities that related through indirect relationships. We find that a small proportion of code entities frequently appear in the FCPCs, and confirm the semantic relationships between code entities covered by 50 instances of FCPCs, indicating potential usefulness for developers to explain the range of change impact from given source code changes.

Frequent co-changes to multiple files, i.e., evolutionary coupling, can demonstrate active relations among files, explicit or implicit. Although evolutionary coupling has been used to analyze software quality, there is no systematic study on the categorization of frequent co-changes between files which may used for characterizing various quality problems. In this paper, we report an empirical study on 27,087 co-change commits of 6 open-source systems with the purpose of understanding the observed evolutionary coupling. We extracted fine-grained change information from version control system to investigate whether two files exhibit particular kinds of co-change relationships. We consider code changes on 5 types of program entities (i.e., field, method, control statement, non-control statement, and class) and identified 6 types of dominating co-change relationships. Our manual analysis showed that each of the 6 types can be explained by structural coupling, semantic coupling, or implicit dependencies. Temporal analysis further shows that files may exhibit different co-change relationships at different phases in the evolution history. Finally, we investigated co-changes among multiple files by combining co-change relationships between related file pairs and showed with live examples that rich information embedded in the fine-grained co-change relationships may help developers to change code at multiple locations. Moreover, we analyzed how these co-change relationship types can be used to facilitate change impact analysis and to pinpoint design problems.

Analyzing and understanding source code changes is important in a variety of software maintenance tasks. To this end, many code differencing and code change summarization methods have been proposed. For some tasks (e.g. code review and software merging), however, those differencing methods generate too fine-grained a representation of code changes, and those summarization methods generate too coarse-grained a representation of code changes. Moreover, they do not consider the relationships among code changes. Therefore, the generated differences or summaries make it not easy to analyze and understand code changes in some software maintenance tasks.