Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings

Understanding which refactoring transformations were performed is in demand in modern software constructions. Traditionally, many researchers have been tackling understanding code changes with history data derived from version control systems. In those studies, problems of the traditional approach a...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:IEICE Transactions on Information and Systems 2018/03/01, Vol.E101.D(3), pp.644-658
Hauptverfasser: OMORI, Takayuki, MARUYAMA, Katsuhisa
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 658
container_issue 3
container_start_page 644
container_title IEICE Transactions on Information and Systems
container_volume E101.D
creator OMORI, Takayuki
MARUYAMA, Katsuhisa
description Understanding which refactoring transformations were performed is in demand in modern software constructions. Traditionally, many researchers have been tackling understanding code changes with history data derived from version control systems. In those studies, problems of the traditional approach are pointed out, such as entanglement of multiple changes. To alleviate the problems, operation histories on IDEs' code editors are available as a new source of software evolution data nowadays. By replaying such histories, we can investigate past code changes in a fine-grained level. However, the prior studies did not provide enough evidence of their effectiveness for detecting refactoring transformations. This paper describes an experiment in which participants detect refactoring transformations performed by other participants after investigating the code changes with an operation-replay tool and diff tools. The results show that both approaches have their respective factors that pose misunderstanding and overlooking of refactoring transformations. Two negative factors on divided operations and generated compound operations were observed in the operation-based approach, whereas all the negative factors resulted from three problems on tangling, shadowing, and out-of-order of code changes in the difference-based approach. This paper also shows seven concrete examples of participants' mistakes in both approaches. These findings give us hints for improving existing tools for understanding code changes and detecting refactoring transformations.
doi_str_mv 10.1587/transinf.2017EDP7160
format Article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_proquest_journals_2014564880</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2014564880</sourcerecordid><originalsourceid>FETCH-LOGICAL-c567t-8d239ae74e2fa91298f4dd1d52231cf3d248a21f56021209b0bd93ce9bde43313</originalsourceid><addsrcrecordid>eNpNkE1PAjEQhhujiYj-Aw9NPC922v08EsCPxETjx7nptlNZAtu1LRL-vUtQ5DRzeJ93Jg8h18BGkJXFbfSqDU1rR5xBMZu-FJCzEzKAIs0SEDmckgGrIE_KTPBzchHCgjEoOWQD4iZu1SmvYvON9C2uzZbWGDeILX3fODruOu-UnmOgH_2FTzozTaTPHe4I1waqWkMnziCdNtaix1b30ejoFCPqSF9UiPQVrdLR-Z4Pl-TMqmXAq985JB93s_fJQ_L0fP84GT8lOsuLmJSGi0phkSK3qgJelTY1BkzGuQBtheFpqTjYLGccOKtqVptKaKxqg6kQIIbkZt_b__-1xhDlwq1925-UvaQ0y9OyZH0q3ae0dyF4tLLzzUr5rQQmd2rln1p5pLbHXvfYIkT1iQdI-djoJf5DM2Agp1L8LUclh7CeKy-xFT8r1Iyo</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2014564880</pqid></control><display><type>article</type><title>Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings</title><source>J-STAGE Free</source><source>EZB-FREE-00999 freely available EZB journals</source><creator>OMORI, Takayuki ; MARUYAMA, Katsuhisa</creator><creatorcontrib>OMORI, Takayuki ; MARUYAMA, Katsuhisa</creatorcontrib><description>Understanding which refactoring transformations were performed is in demand in modern software constructions. Traditionally, many researchers have been tackling understanding code changes with history data derived from version control systems. In those studies, problems of the traditional approach are pointed out, such as entanglement of multiple changes. To alleviate the problems, operation histories on IDEs' code editors are available as a new source of software evolution data nowadays. By replaying such histories, we can investigate past code changes in a fine-grained level. However, the prior studies did not provide enough evidence of their effectiveness for detecting refactoring transformations. This paper describes an experiment in which participants detect refactoring transformations performed by other participants after investigating the code changes with an operation-replay tool and diff tools. The results show that both approaches have their respective factors that pose misunderstanding and overlooking of refactoring transformations. Two negative factors on divided operations and generated compound operations were observed in the operation-based approach, whereas all the negative factors resulted from three problems on tangling, shadowing, and out-of-order of code changes in the difference-based approach. This paper also shows seven concrete examples of participants' mistakes in both approaches. These findings give us hints for improving existing tools for understanding code changes and detecting refactoring transformations.</description><identifier>ISSN: 0916-8532</identifier><identifier>EISSN: 1745-1361</identifier><identifier>DOI: 10.1587/transinf.2017EDP7160</identifier><language>eng</language><publisher>Tokyo: The Institute of Electronics, Information and Communication Engineers</publisher><subject>Change detection ; Entanglement ; Errors ; fine-grained code change ; refactoring detection ; Software ; software evolution ; Tangling ; Transformations ; understanding code change ; Version control</subject><ispartof>IEICE Transactions on Information and Systems, 2018/03/01, Vol.E101.D(3), pp.644-658</ispartof><rights>2018 The Institute of Electronics, Information and Communication Engineers</rights><rights>Copyright Japan Science and Technology Agency 2018</rights><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c567t-8d239ae74e2fa91298f4dd1d52231cf3d248a21f56021209b0bd93ce9bde43313</citedby><cites>FETCH-LOGICAL-c567t-8d239ae74e2fa91298f4dd1d52231cf3d248a21f56021209b0bd93ce9bde43313</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,777,781,1877,27905,27906</link.rule.ids></links><search><creatorcontrib>OMORI, Takayuki</creatorcontrib><creatorcontrib>MARUYAMA, Katsuhisa</creatorcontrib><title>Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings</title><title>IEICE Transactions on Information and Systems</title><addtitle>IEICE Trans. Inf. &amp; Syst.</addtitle><description>Understanding which refactoring transformations were performed is in demand in modern software constructions. Traditionally, many researchers have been tackling understanding code changes with history data derived from version control systems. In those studies, problems of the traditional approach are pointed out, such as entanglement of multiple changes. To alleviate the problems, operation histories on IDEs' code editors are available as a new source of software evolution data nowadays. By replaying such histories, we can investigate past code changes in a fine-grained level. However, the prior studies did not provide enough evidence of their effectiveness for detecting refactoring transformations. This paper describes an experiment in which participants detect refactoring transformations performed by other participants after investigating the code changes with an operation-replay tool and diff tools. The results show that both approaches have their respective factors that pose misunderstanding and overlooking of refactoring transformations. Two negative factors on divided operations and generated compound operations were observed in the operation-based approach, whereas all the negative factors resulted from three problems on tangling, shadowing, and out-of-order of code changes in the difference-based approach. This paper also shows seven concrete examples of participants' mistakes in both approaches. These findings give us hints for improving existing tools for understanding code changes and detecting refactoring transformations.</description><subject>Change detection</subject><subject>Entanglement</subject><subject>Errors</subject><subject>fine-grained code change</subject><subject>refactoring detection</subject><subject>Software</subject><subject>software evolution</subject><subject>Tangling</subject><subject>Transformations</subject><subject>understanding code change</subject><subject>Version control</subject><issn>0916-8532</issn><issn>1745-1361</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2018</creationdate><recordtype>article</recordtype><recordid>eNpNkE1PAjEQhhujiYj-Aw9NPC922v08EsCPxETjx7nptlNZAtu1LRL-vUtQ5DRzeJ93Jg8h18BGkJXFbfSqDU1rR5xBMZu-FJCzEzKAIs0SEDmckgGrIE_KTPBzchHCgjEoOWQD4iZu1SmvYvON9C2uzZbWGDeILX3fODruOu-UnmOgH_2FTzozTaTPHe4I1waqWkMnziCdNtaix1b30ejoFCPqSF9UiPQVrdLR-Z4Pl-TMqmXAq985JB93s_fJQ_L0fP84GT8lOsuLmJSGi0phkSK3qgJelTY1BkzGuQBtheFpqTjYLGccOKtqVptKaKxqg6kQIIbkZt_b__-1xhDlwq1925-UvaQ0y9OyZH0q3ae0dyF4tLLzzUr5rQQmd2rln1p5pLbHXvfYIkT1iQdI-djoJf5DM2Agp1L8LUclh7CeKy-xFT8r1Iyo</recordid><startdate>20180101</startdate><enddate>20180101</enddate><creator>OMORI, Takayuki</creator><creator>MARUYAMA, Katsuhisa</creator><general>The Institute of Electronics, Information and Communication Engineers</general><general>Japan Science and Technology Agency</general><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope></search><sort><creationdate>20180101</creationdate><title>Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings</title><author>OMORI, Takayuki ; MARUYAMA, Katsuhisa</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c567t-8d239ae74e2fa91298f4dd1d52231cf3d248a21f56021209b0bd93ce9bde43313</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2018</creationdate><topic>Change detection</topic><topic>Entanglement</topic><topic>Errors</topic><topic>fine-grained code change</topic><topic>refactoring detection</topic><topic>Software</topic><topic>software evolution</topic><topic>Tangling</topic><topic>Transformations</topic><topic>understanding code change</topic><topic>Version control</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>OMORI, Takayuki</creatorcontrib><creatorcontrib>MARUYAMA, Katsuhisa</creatorcontrib><collection>CrossRef</collection><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts – Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection><jtitle>IEICE Transactions on Information and Systems</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>OMORI, Takayuki</au><au>MARUYAMA, Katsuhisa</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings</atitle><jtitle>IEICE Transactions on Information and Systems</jtitle><addtitle>IEICE Trans. Inf. &amp; Syst.</addtitle><date>2018-01-01</date><risdate>2018</risdate><volume>E101.D</volume><issue>3</issue><spage>644</spage><epage>658</epage><pages>644-658</pages><issn>0916-8532</issn><eissn>1745-1361</eissn><abstract>Understanding which refactoring transformations were performed is in demand in modern software constructions. Traditionally, many researchers have been tackling understanding code changes with history data derived from version control systems. In those studies, problems of the traditional approach are pointed out, such as entanglement of multiple changes. To alleviate the problems, operation histories on IDEs' code editors are available as a new source of software evolution data nowadays. By replaying such histories, we can investigate past code changes in a fine-grained level. However, the prior studies did not provide enough evidence of their effectiveness for detecting refactoring transformations. This paper describes an experiment in which participants detect refactoring transformations performed by other participants after investigating the code changes with an operation-replay tool and diff tools. The results show that both approaches have their respective factors that pose misunderstanding and overlooking of refactoring transformations. Two negative factors on divided operations and generated compound operations were observed in the operation-based approach, whereas all the negative factors resulted from three problems on tangling, shadowing, and out-of-order of code changes in the difference-based approach. This paper also shows seven concrete examples of participants' mistakes in both approaches. These findings give us hints for improving existing tools for understanding code changes and detecting refactoring transformations.</abstract><cop>Tokyo</cop><pub>The Institute of Electronics, Information and Communication Engineers</pub><doi>10.1587/transinf.2017EDP7160</doi><tpages>15</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 0916-8532
ispartof IEICE Transactions on Information and Systems, 2018/03/01, Vol.E101.D(3), pp.644-658
issn 0916-8532
1745-1361
language eng
recordid cdi_proquest_journals_2014564880
source J-STAGE Free; EZB-FREE-00999 freely available EZB journals
subjects Change detection
Entanglement
Errors
fine-grained code change
refactoring detection
Software
software evolution
Tangling
Transformations
understanding code change
Version control
title Comparative Study between Two Approaches Using Edit Operations and Code Differences to Detect Past Refactorings
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-20T19%3A49%3A55IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Comparative%20Study%20between%20Two%20Approaches%20Using%20Edit%20Operations%20and%20Code%20Differences%20to%20Detect%20Past%20Refactorings&rft.jtitle=IEICE%20Transactions%20on%20Information%20and%20Systems&rft.au=OMORI,%20Takayuki&rft.date=2018-01-01&rft.volume=E101.D&rft.issue=3&rft.spage=644&rft.epage=658&rft.pages=644-658&rft.issn=0916-8532&rft.eissn=1745-1361&rft_id=info:doi/10.1587/transinf.2017EDP7160&rft_dat=%3Cproquest_cross%3E2014564880%3C/proquest_cross%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=2014564880&rft_id=info:pmid/&rfr_iscdi=true