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

Vdiff: a program differencing algorithm for Verilog hardware description language

AUTOMATED SOFTWARE ENGINEERING 2012年第4期19卷 459-490页

作者： Duley, Adam Spandikow, Chris Kim, Miryung Univ Texas Austin Austin TX 78712 USA ARM Inc Austin TX 78746 USA IBM Corp Austin TX 78758 USA

During code review tasks, comparing two versions of a hardware design description using existing program differencing tools such as diff is inherently limited because these tools implicitly assume sequential execution semantics, while hardware description languages are designed to model concurrent computation. We designed a position-independent differencing algorithm to robustly handle language constructs whose relative orderings do not matter. This paper presents Vdiff, an instantiation of this position-independent differencing algorithm for Verilog HDL. To help programmers reason about the differences at a high-level, Vdiff outputs syntactic differences in terms of Verilog-specific change types. The quantitative evaluation of Vdiff on two open source hardware design projects shows that Vdiff is very accurate, with overall 96.8 % precision and 97.3 % recall when using manually classified differences as a basis of comparison. Vdiff is also fast and scalable-it processes the entire revision history of nine open projects all under 5.35 minutes. We conducted a user study with eight hardware design experts to understand how the program differences identified by the experts match Vdiff's output. The study results show that Vdiff's output is better aligned with the experts' classification of Verilog changes than an existing textual program differencing tool.

关键词： Software evolution program differencing Hardware description languages

来源：评论

学校读者我要写书评

暂无评论

Identifying and Summarizing Systematic Code Changes via Rule Inference

引用

IEEE TRANSACTIONS ON SOFTWARE ENGINEERING 2013年第1期39卷 45-62页

作者： Kim, Miryung Notkin, David Grossman, Dan Wilson, Gary, Jr. Univ Texas Austin Dept Elect & Comp Engn Austin TX 78712 USA Univ Washington Dept Comp Sci & Engn Seattle WA 98195 USA Univ Washington Comp Sci & Engn Fac Seattle WA 98195 USA

programmers often need to reason about how a program evolved between two or more program versions. Reasoning about program changes is challenging as there is a significant gap between how programmers think about changes and how existing program differencing tools represent such changes. For example, even though modification of a locking protocol is conceptually simple and systematic at a code level, diff extracts scattered text additions and deletions per file. To enable programmers to reason about program differences at a high level, this paper proposes a rule-based program differencing approach that automatically discovers and represents systematic changes as logic rules. To demonstrate the viability of this approach, we instantiated this approach at two different abstraction levels in Java: first at the level of application programming interface (API) names and signatures, and second at the level of code elements (e.g., types, methods, and fields) and structural dependences (e.g., method-calls, field-accesses, and subtyping relationships). The benefit of this approach is demonstrated through its application to several open source projects as well as a focus group study with professional software engineers from a large e-commerce company.

关键词： Software evolution program differencing rule learning logic-based program representation

来源：评论

学校读者我要写书评

暂无评论

JDiff: A differencing technique and tool for object-oriented programs

引用

AUTOMATED SOFTWARE ENGINEERING 2007年第1期14卷 3-36页

作者： Apiwattanapong, Taweesup Orso, Alessandro Harrold, Mary Jean Georgia Inst Technol Atlanta GA 30332 USA

During software evolution, information about changes between different versions of a program is useful for a number of software engineering tasks. For example, configuration-management systems can use change information to assess possible conflicts among updates from different users. For another example, in regression testing, knowledge about which parts of a program are unchanged can help in identifying test cases that need not be rerun. For many of these tasks, a purely syntactic differencing may not provide enough information for the task to be performed effectively. This problem is especially relevant in the case of object-oriented software, for which a syntactic change can have subtle and unforeseen effects. In this paper, we present a technique for comparing object-oriented programs that identifies both differences and correspondences between two versions of a program. The technique is based on a representation that handles object-oriented features and, thus, can capture the behavior of object-oriented programs. We also present JD(IFF), a tool that implements the technique for Java programs. Finally, we present the results of four empirical studies, performed on many versions of two medium-sized subjects, that show the efficiency and effectiveness of the technique when used on real programs.

关键词： program differencing software evolution

来源：评论

学校读者我要写书评

暂无评论

Hammock-based Identification of Changes in Advice Applications between Aspect-oriented programs 14

Hammock-based Identification of Changes in Advice Applicatio...

引用

14th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE)

作者： Katic, Marija Independent Researcher London United Kingdom

ISBN: (纸本)9789897583759

In an aspect-oriented program, the cross-cutting functionalities are defined in pieces of advice such that they apply to program-execution points for the core functionalities. program changes can affect the application of pieces of advice. To that end, a source-code differencing tool, for two versions of an aspect-oriented program, needs to support the identification of changes in pieces of advice at locations of their applications. To alleviate this task, we introduce an extension of the existing differencing technique for object-oriented programs. We implemented a tool AjDiff and used it to evaluate our technique on the two examples of aspect-oriented programs: Tracing and Telecom. We manually verified that our tool can successfully identify changes in pieces of advice at locations of their application.

关键词： Aspect-oriented programming program differencing CFG Comparison Hammock Hammock Graphs

来源：评论

学校读者我要写书评

暂无评论

Directed Incremental Symbolic Execution 11

Directed Incremental Symbolic Execution

引用

32nd ACM SIGPLAN Conference on programming Language Design and Implementation (PLDI 11)

作者： Person, Suzette Yang, Guowei Rungta, Neha Khurshid, Sarfraz NASA Langley Res Ctr Washington DC 20546 USA

ISBN: (纸本)9781450306638

The last few years have seen a resurgence of interest in the use of symbolic execution - a program analysis technique developed more than three decades ago to analyze program execution paths. Scaling symbolic execution and other path-sensitive analysis techniques to large systems remains challenging despite recent algorithmic and technological advances. An alternative to solving the problem of scalability is to reduce the scope of the analysis. One approach that is widely studied in the context of regression analysis is to analyze the differences between two related program versions. While such an approach is intuitive in theory, finding efficient and precise ways to identify program differences, and characterize their effects on how the program executes has proved challenging in practice. In this paper, we present Directed Incremental Symbolic Execution (DiSE), a novel technique for detecting and characterizing the effects of program changes. The novelty of DiSE is to combine the efficiencies of static analysis techniques to compute program difference information with the precision of symbolic execution to explore program execution paths and generate path conditions affected by the differences. DiSE is a complementary technique to other reduction or bounding techniques developed to improve symbolic execution. Furthermore, DiSE does not require analysis results to be carried forward as the software evolves-only the source code for two related program versions is required. A case-study of our implementation of DiSE illustrates its effectiveness at detecting and characterizing the effects of program changes.

关键词： program differencing Symbolic Execution Software Evolution

来源：评论

学校读者我要写书评

暂无评论

Using improved context-based code description for robust algorithmic binding to changing code 10

Using improved context-based code description for robust alg...

引用

10th International Young Scientists Conference in Computational Science (YSC)

作者： Goloveshkin, Alexey Mikhalkovich, Stanislav Southern Fed Univ Inst Math Mech & Comp Sci Milchakova Str 8a Rostov Na Donu 344090 Russia

In a computer program, multiple problems are usually solved, both domain-specific and technical. The solution of a problem can be concentrated in a single decomposition element (e.g. class or method) or be implemented with multiple code fragments scattered throughout the codebase. With no supporting tools, scattered solutions are hard to explore and modify, because the fact that there is a the high-level semantic connection between some code fragments is not articulated in the code itself. To overcome this difficulty, programmers need a special tool to mark all the fragments that solve a single problem (to bind to them) and then use this markup to navigate through the project. The markup must be robust, i.e., all the fragments previously marked must be successfully found in the changed code. A method for achieving this robustness has recently been proposed. It consists in representing the marked code fragment as a set of structures called "contexts". Contexts capture valuable information about the fragment and its surrounding. This information is then used to find the fragment algorithmically in the edited code. In the present paper, the method is further improved. More informative contexts and more precise search algorithms are presented, allowing the tool to automatically find the vast majority of previously marked fragments existing in the edited code. (C) 2021 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC -ND license (https:ficreatit ***11.0) Peer-review under responsibility of the scientific committee of the 10th International Young Scientists Conference on Computational Science

关键词： program markup algorithmic binding to code program representation code similarity measurement program differencing scattered code crosscutting concern software evolution

来源：评论

学校读者我要写书评

暂无评论

Critics: An Interactive Code Review Tool for Searching and Inspecting Systematic Changes 22

Critics: An Interactive Code Review Tool for Searching and I...

引用

22nd ACM SIGSOFT International Symposium on the Foundations of Software Engineering (FSE)

作者： Zhang, Tianyi Song, Myoungkyu Kim, Miryung Univ Calif Los Angeles Los Angeles CA 90024 USA Univ Texas Austin Austin TX 78712 USA

ISBN: (纸本)9781450330565

During peer code reviews, developers often examine program differences. When using existing program differencing tools, it is difficult for developers to inspect systematic changes-similar, related changes that are scattered across multiple files. Developers cannot easily answer questions such as "what other code locations changed similar to this change?" and "are there any other locations that are similar to this code but are not updated? In this paper, we demonstrate Critics, an Eclipse plug-in that assists developers in inspecting systematic changes. It (1) allows developers to customize a context-aware change template, (2) searches for systematic changes using the template, and (3) detects missing or inconsistent edits. Developers can interactively re fine the customized change template to see corresponding search results. Critics has potential to improve developer productivity in inspecting large, scattered edits during code reviews. The tool's demonstration video is available at https://***/watch?v=F2D7t_Z5rhk

关键词： Software evolution program differencing code reviews

来源：评论

学校读者我要写书评

暂无评论

Finding and Use of Source Code Changes for Aspect-Oriented Software 15th

Finding and Use of Source Code Changes for Aspect-Oriented S...

引用

15th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE)

作者： Katic, Marija London United Kingdom

ISBN: (纸本)9783030700058;9783030700065

In aspect-oriented software, code contained in special constructs called pieces of advice is used to define cross-cutting functionalities. This code is separated from more purpose-specific code (base code) and applies to it at specified program execution points called join-points. Such mechanism of composing a program imposes new requirements for finding changes between two versions of aspect-oriented software. This particularly refers to finding changes in advice applications at join-points as these applications are rather implict due to the absence of syntactical dependence of the base code to pieces of advice. In our previous work, we proposed and evaluated a novel approach for finding changes in advice applications. In this paper, we overview that approach, provide more details about how it works and additional results of manual verification analysis. We also compare the state-of-the-art approaches for finding and use of changes between two aspect-oriented software versions, including our previous work. Finally, we introduce the implementation of the graphical user interface for presenenting the changes found with our approach. We discuss its perspective usage and other potential applications of our approach.

关键词： program differencing Aspect-oriented programming Software evolution

来源：评论

学校读者我要写书评

暂无评论

LAC: Locating and Applying Consistent and Repetitive Changes 43

LAC: Locating and Applying Consistent and Repetitive Changes

引用

43rd IEEE-Computer-Society Annual International Computers, Software and Applications Conference (COMPSAC)

作者： Sakala, Sushma Epuri, Vamshi Krishna Cho, Samuel Sungmin Song, Myoungkyu Univ Nebraska Omaha NE 68182 USA Northern Kentucky Univ Highland Hts KY USA

ISBN: (纸本)9781728126074

As a software system evolves, constant changes are usually made in the code. Similar changes to code fragments often occur in multiple locations. It is very tedious and error prone for developers to manually update similar changes in multiple locations. To address this problem, we propose an approach for Locating and Applying Consistent and Repetitive Changes (LAC) as an Eclipse plug-in. LAC analyzes the code fragments to detect change anomalies, such as omissions or inconsistent edits, and automatically repairs these anomalies by applying required changes. Our static analysis technique to detect anomalies is carried out by inferring change patterns. The evaluation results in a user study show that automatically applying repetitive changes in identified locations using LAC correctly matches with that of manually updated ones, which significantly decreases manual efforts and error-prone edits.

关键词： Change pattern program differencing Software evolution

来源：评论

学校读者我要写书评

暂无评论

Detecting Differences across Multiple Instances of Code Clones 2014

Detecting Differences across Multiple Instances of Code Clon...

引用

36th International Conference on Software Engineering (ICSE)

作者： Lin, Yun Xing, Zhenchang Xue, Yinxing Liu, Yang Peng, Xin Sun, Jun Zhao, Wenyun Fudan Univ Sch Comp Sci Shanghai Peoples R China Fudan Univ Shanghai Key Lab Data Sci Shanghai Peoples R China Nanyang Technol Univ Sch Comp Engn Singapore Singapore Natl Univ Singapore Sch Comp Singapore Singapore Singapore Univ Technol & Design Singapore Singapore

ISBN: (纸本)9781450327565

Clone detectors find similar code fragments (i.e., instances of code clones) and report large numbers of them for industrial systems. To maintain or manage code clones, developers often have to investigate differences of multiple cloned code fragments. However, existing program differencing techniques compare only two code fragments at a time. Developers then have to manually combine several pairwise differencing results. In this paper, we present an approach to automatically detecting differences across multiple clone instances. We have implemented our approach as an Eclipse plugin and evaluated its accuracy with three Java software systems. Our evaluation shows that our algorithm has precision over 97.66% and recall over 95.63% in three open source Java projects. We also conducted a user study of 18 developers to evaluate the usefulness of our approach for eight clone-related refactoring tasks. Our study shows that our approach can significantly improve developers' performance in refactoring decisions, refactoring details, and task completion time on clone-related refactoring tasks. Automatically detecting differences across multiple clone instances also opens opportunities for building practical applications of code clones in software maintenance, such as auto-generation of application skeleton, intelligent simultaneous code editing.

关键词： Code clone program differencing Human study

来源：评论

学校读者我要写书评

暂无评论

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

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

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

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

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

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

通借通还

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

请选择保存的检索档案：

请选择收藏分类：