检索结果-内蒙古大学图书馆

35th IEEE International Conference on Software Maintenance and Evolution (ICSME)

作者： Yang, Chunhua Whitehead, Jim Qilu Univ Technol Shandong Acad Sci Sch Comp Sci & Technol Jinan Peoples R China Univ Calif Santa Cruz Dept Computat Media Santa Cruz CA 95064 USA

ISBN: (纸本)9781728130941

As current tree-differencing approaches ignore changes that occur within a statement or do not present them in an abstract way, it is difficult to automatically understand revisions involving statement updates. We propose a tree-differencing approach to identifying the within-statement changes. It calculates edit operations based on an element-sensitive strategy and the longest common sequence algorithm. Then, it generates the metadata for each edit operation. Meta-data include the type of operation, the type of entity and the name of the element part, the content, the content pattern and all references involved. We have implemented the approach as a free accessible tool. It is built upon ChangeDistiller and refines its statement-update type. Finally, to demonstrate how to use the proposed approach for change understanding, we studied the condition-expression changes in four open projects. We analyzed the non-essential condition changes, the effective changes that definitely affect the condition, and other changes. The results show that for revisions with condition-expression changes, nearly 20% contain non-essential changes, while more than 60% have effective changes. Furthermore, we found many common patterns. For example, we found that half of the revisions with effective changes were caused by adding or removing expressions in logical expressions. And, in these revisions, 47% enhanced the condition, while 49% weakened it.

关键词： code differencing code changes change understanding software evolution

来源：评论

学校读者我要写书评

暂无评论

TBCUP: A Transformer-based code Comments Updating Approach 47

TBCUP: A Transformer-based Code Comments Updating Approach

引用

47th IEEE-Computer-Society Annual International Conference on Computers, Software, and Applications (COMPSAC)

作者： Liu, Shifan Cui, Zhanqi Chen, Xiang Yang, Jun Li, Li Zheng, Liwei Beijing Informat Sci & Technol Univ Sch Comp Sci Beijing Peoples R China Nantong Univ Sch Informat Sci & Technol Nantong Peoples R China

ISBN: (纸本)9798350326970

Good code comments are of great value for program maintenance. However, during the development process, developers often neglect to update the corresponding comments when changing the code, which results in inconsistent comments and affects the maintainability of software. Studies have shown that even in widely used programs, there is a large number of outdated comments. Existing code comment update approaches use long short-term memory (LSTM) model based on encoder-decoder to capture the relationship between code changes and comment updates, to automatically update code comments. However, due to the complexity of code changes, the corresponding comments update results do not perform well. Thus, a Transformer-based automatic update approach for code comments called TBCUP is proposed in this paper. TBCUP uses the multi-head attention mechanism to learn the relationship between code change sequences and comment updates to update comments more accurately. In addition, TBCUP uses the Byte Pair Encoding (BPE) algorithm to build a unified vocabulary for code and corresponding comments to alleviate the problem of out-of-vocabulary (OOV) words while updating comments. With BPE, TBCUP can split or combine words to handle OOV words. The experimental results on the dataset containing 108k sets of code-comment co-evolution samples show that the accuracy of TBCUP is improved by 3.2% in comparison with CUP.

关键词： program comprehension comment updating deep learning sequence-to-sequence model code changes

来源：评论

学校读者我要写书评

暂无评论

An Exploratory Study on the Relationship between changes and Refactoring 25

An Exploratory Study on the Relationship between Changes and...

引用

25th IEEE/ACM International Conference on Program Comprehension (ICPC)

作者： Palomba, Fabio Zaidman, Andy Oliveto, Rocco De Lucia, Andrea Delft Univ Technol Delft Netherlands Univ Salerno Fisciano Italy Univ Molise Campobasso Italy

ISBN: (纸本)9781538605356

Refactoring aims at improving the internal structure of a software system without changing its external behavior. Previous studies empirically assessed, on the one hand, the benefits of refactoring in terms of code quality and developers' productivity, and on the other hand, the underlying reasons that push programmers to apply refactoring. Results achieved in the latter investigations indicate that besides personal motivation such as the responsibility concerned with code authorship, refactoring is mainly performed as a consequence of changes in the requirements rather than driven by software quality. However, these findings have been derived by surveying developers, and therefore no software repository study has been carried out to corroborate the achieved findings. To bridge this gap, we provide a quantitative investigation on the relationship between different types of code changes (i.e., Fault Repairing Modification, Feature Introduction Modification, and General Maintenance Modification) and 28 different refactoring types coming from 3 open source projects. Results showed that developers tend to apply a higher number of refactoring operations aimed at improving maintainability and comprehensibility of the source code when fixing bugs. Instead, when new features are implemented, more complex refactoring operations are performed to improve code cohesion. Most of the times, the underlying reasons behind the application of such refactoring operations are represented by the presence of duplicate code or previously introduced self-admitted technical debts.

关键词： Refactoring code changes Empirical Studies

来源：评论

学校读者我要写书评

暂无评论

FS³change: A Scalable Method for Change Pattern Mining

引用

IEEE TRANSACTIONS ON SOFTWARE ENGINEERING 2023年第6期49卷 3616-3629页

作者： Janke, Mario Maeder, Patrick Tech Univ Ilmenau Software Engn Data Intens Syst & Visualizat Grp dA D-98693 Ilmenau Germany Friedrich Schiller Univ Fac Biol Sci D-07743 Jena Germany

Mining change patterns can give unique understanding on the evolution of dynamically changing systems like social relation graphs, weblinks, hardware descriptions and models. A more recent focus is source code change pattern mining that may qualitatively justify expected or uncover unexpected patterns. These patterns then offer a basis, e.g., for program language evolution or auto-completion support. We present a change pattern mining method that greatly expands the limits of input data and pattern complexity, over existing methods. We propose scalability solutions on conceptual and algorithmic level, thereby evolving the state-of-the-art sampling-based frequent subgraph mining method FS3, resulting in 75% reduction in memory consumption and a speedup of 6500 for a large scale dataset. Patterns can have 100,000 s of occurrences for which manual review is impossible and may lead to misinterpretation. We propose the novel content track approach for interactively exploring pattern contents in context, based on marginal distributions. We evaluate our approach by mining 1,000 open source projects contributing a total of 558 million changes and 2 billion contextual connections among them, thereby, demonstrating its scalability. A manual interpretation of 19 patterns shows sensible mined patterns allowing to deduct implications for language design and demonstrating the soundness of the approach.

关键词： Auto-completion change patterns code changes data mining frequent graph mining scalability

来源：评论

学校读者我要写书评

暂无评论

Visualization of aggregated information to support class-level software evolution?

引用

JOURNAL OF SYSTEMS AND SOFTWARE 2022年 192卷

作者： Rahimi, Mona Vierhauser, Michael Northern Illinois Univ 100 Normal Rd De Kalb IL 60115 USA Johannes Kepler Univ Linz Dept Business Informat Software Engn Altenberger Str 69 A-4040 Linz Austria

Context: Software is inherently prone to constant change, especially in the source code, making it difficult for developers to keep track of changes performed over time and to fully understand their implications. Objective: To this end, we present an Eclipse plug-in for visualizing heterogeneous information, collected from multiple sources, at different levels of granularity. This visualization provides a single graphical representation of a system's change histories over multiple versions, allowing developers to identify the previous and present dependencies in the system, while adding new or removing and modifying the current functionalities of a software. Summarizing and associating the relevant changes in a single graph, further supports developers, not familiar with the overall system, to conduct a self-study and explore the systems design and changes of its functionality over time. Method: Our tool, DejaVu, initially infers and further visualizes change scenarios that have been applied to a given class in source code, across multiple versions of a software. DejaVu additionally augments the change information with prior commits from GitHub repositories, as well as associated issues from Jira issue tracking system. Evaluation: As part of the evaluation, we conducted a controlled experiment, recruiting participants with research or industrial programming experiences. The participants were asked to investigate and assess a set of change stories with and without the use of the DejaVu. As such, we empirically evaluated the impact of DejaVu in alleviating developers' understanding of code class-level changes across multiple versions. Results: Our results showed an average of 52% reduction in completion time and a 51% increase in correctness of several change-comprehension tasks once, users adopted DejaVu in comparison to the manual completion of the same tasks. A student's t-test verified the significant improvement in time and correctness of the tasks with p-values

关键词： code changes Change visualization Software evolution

来源：评论

学校读者我要写书评

暂无评论

Slicing Fine-Grained code Change History

引用

IEICE TRANSACTIONS ON INFORMATION AND SYSTEMS 2016年第3期E99D卷 671-687页

作者： Maruyama, Katsuhisa Omori, Takayuki Hayashi, Shinpei Ritsumeikan Univ Dept Comp Sci Kusatsu 5258577 Japan Tokyo Inst Technol Dept Comp Sci Tokyo 1528552 Japan

Change-aware development environments can automatically record fine-grained code changes on a program and allow programmers to replay the recorded changes in chronological order. However, since they do not always need to replay all the code changes to investigate how a particular entity of the program has been changed, they often eliminate several code changes of no interest by manually skipping them in replaying. This skipping action is an obstacle that makes many programmers hesitate when they use existing replaying tools. This paper proposes a slicing mechanism that automatically removes manually skipped code changes from the whole history of past code changes and extracts only those necessary to build a particular class member of a Java program. In this mechanism, fine-grained code changes are represented by edit operations recorded on the source code of a program and dependencies among edit operations are formalized. The paper also presents a running tool that slices the operation history and replays its resulting slices. With this tool, programmers can avoid replaying nonessential edit operations for the construction of class members that they want to understand. Experimental results show that the tool offered improvements over conventional replaying tools with respect to the reduction of the number of edit operations needed to be examined and over history filtering tools with respect to the accuracy of edit operations to be replayed.

关键词： software maintenance and evolution program comprehension integrated development environments program slicing code changes

来源：评论

学校读者我要写书评

暂无评论

Unprecedented code Change Automation: The Fusion of LLMs and Transformation by Example

Proceedings of the ACM on Software Engineering

引用

Proceedings of the ACM on Software Engineering 2024年第FSE期1卷 631-653页

作者： Malinda Dilhara Abhiram Bellur Timofey Bryksin Danny Dig University of Colorado Boulder USA JetBrains Research Limassol Cyprus JetBrains Research - University of Colorado Boulder USA

Software developers often repeat the same code changes within a project or across different projects. These repetitive changes are known as “code change patterns” (CPATs). Automating CPATs is crucial to expedite the software development process. While current Transformation by Example (TBE) techniques can automate CPATs, they are limited by the quality and quantity of the provided input examples. Thus, they miss transforming code variations that do not have the exact syntax, data-, or control-flow of the provided input examples, despite being semantically similar. Large Language Models (LLMs), pre-trained on extensive source code datasets, offer a potential solution. Harnessing the capability of LLMs to generate semantically equivalent, yet previously unseen variants of the original CPAT could significantly increase the effectiveness of TBE systems. In this paper, we first discover best practices for harnessing LLMs to generate code variants that meet three criteria: correctness (semantic equivalence to the original CPAT), usefulness (reflecting what developers typically write), and applicability (aligning with the primary intent of the original CPAT). We then implement these practices in our tool PyCraft, which synergistically combines static code analysis, dynamic analysis, and LLM capabilities. By employing chain-of-thought reasoning, PyCraft generates variations of input examples and comprehensive test cases that identify correct variations with an F-measure of 96.6%. Our algorithm uses feedback iteration to expand the original input examples by an average factor of 58x. Using these richly generated examples, we inferred transformation rules and then automated these changes, resulting in an increase of up to 39x, with an average increase of 14x in target codes compared to a previous state-of-the-art tool that relies solely on static analysis. We submitted patches generated by PyCraft to a range of projects, notably esteemed ones like microsoft/DeepSpeed and IBM/

关键词： Automation code changes code Clone Generative AI Large Language Models Machine Learning Program by Example Python Test Case Generation Transformation by Example

来源：评论

学校读者我要写书评

暂无评论

7 Dimensions of software change patterns

引用

SCIENTIFIC REPORTS 2024年第1期14卷 1-17页

作者： Janke, Mario Maeder, Patrick Tech Univ Ilmenau Data intens Syst & Visualizat Grp Helmholtzpl D-98693 Ilmenau Thuringia Germany

Evolving software is a highly complex and creative problem in which a number of different strategies are used to solve the tasks at hand. These strategies and reoccurring coding patterns can offer insights into the process. However, they can be highly project or even task-specific. We aim to identify code change patterns in order to draw conclusions about the software development process. For this, we propose a novel way to calculate high-level file overarching diffs, and a novel way to parallelize pattern mining. In a study of 1000 Java projects, we mined and analyzed a total of 45,000 patterns. We present 13 patterns, showing extreme points of the 7 pattern categories we identified. We found that a large number of high-level change patterns exist and occur frequently. The majority of mined patterns were associated with a specific project and contributor, where and by whom it was more likely to be used. While a large number of different code change patterns are used, only a few, mostly unsurprising ones, are common under all circumstances. The majority of code change patterns are highly specific to different context factors that we further explore.

关键词： code changes Data mining Frequent graph mining Auto-completion

来源：评论

学校读者我要写书评

暂无评论

Automatic Identification of Similar Pull-Requests in GitHub's Repositories Using Machine Learning

引用

INFORMATION 2022年第2期13卷

作者： Eyal Salman, Hamzeh Alshara, Zakarea Seriai, Abdelhak-Djamel Mutah Univ IT Fac Software Engn Dept Al Karak 61710 Jordan Jordan Univ Sci & Technol IT Fac Software Engn Dept Irbid 22110 Jordan Univ Montpellier LIRMM Lab F-34000 Montpellier France

Context: In a social coding platform such as GitHub, a pull-request mechanism is frequently used by contributors to submit their code changes to reviewers of a given repository. In general, these code changes are either to add a new feature or to fix an existing bug. However, this mechanism is distributed and allows different contributors to submit unintentionally similar pull-requests that perform similar development activities. Similar pull-requests may be submitted to review in parallel time by different reviewers. This will cause redundant reviewing time and efforts. Moreover, it will complicate the collaboration process. Objective: Therefore, it is useful to assign similar pull-requests to the same reviewer to be able to decide which pull-request to choose in effective time and effort. In this article, we propose to group similar pull-requests together into clusters so that each cluster is assigned to the same reviewer or the same reviewing team. This proposal allows saving reviewing efforts and time. Method: To do so, we first extract descriptive textual information from pull-requests content to link similar pull-requests together. Then, we employ the extracted information to find similarities among pull-requests. Finally, machine learning algorithms (K-Means clustering and agglomeration hierarchical clustering algorithms) are used to group similar pull-requests together. Results: To validate our proposal, we have applied it to twenty popular repositories from public dataset. The experimental results show that the proposed approach achieved promising results according to the well-known metrics in this subject: precision and recall. Furthermore, it helps to save the reviewer time and effort. Conclusion: According to the obtained results, the K-Means algorithm achieves 94% and 91% average precision and recall values over all considered repositories, respectively, while agglomeration hierarchical clustering performs 93% and 98% average precision and recall values

关键词： pull-requests similarity GitHub machine learning code changes review

来源：评论

学校读者我要写书评

暂无评论

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

建议与咨询 留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案： 新增检索档案 确定 取消

请选择收藏分类： 新增自定义分类 确定 取消

通借通还

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

请选择保存的检索档案：

请选择收藏分类：