Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance

In recent years, Complex Network theory and graph algorithms have been proved to be effective in predicting software bugs. On the other hand, as a widely-used algorithm in Complex Network theory, k-core decomposition has been used in software engineering domain to identify key classes. Intuitively,...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:IEEE transactions on software engineering 2021-02, Vol.47 (2), p.348-366
Hauptverfasser: Qu, Yu, Zheng, Qinghua, Chi, Jianlei, Jin, Yangxu, He, Ancheng, Cui, Di, Zhang, Hengshan, Liu, Ting
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext bestellen
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 366
container_issue 2
container_start_page 348
container_title IEEE transactions on software engineering
container_volume 47
creator Qu, Yu
Zheng, Qinghua
Chi, Jianlei
Jin, Yangxu
He, Ancheng
Cui, Di
Zhang, Hengshan
Liu, Ting
description In recent years, Complex Network theory and graph algorithms have been proved to be effective in predicting software bugs. On the other hand, as a widely-used algorithm in Complex Network theory, k-core decomposition has been used in software engineering domain to identify key classes. Intuitively, key classes are more likely to be buggy since they participate in more functions or have more interactions and dependencies. However, there is no existing research uses k -core decomposition to analyze software bugs. To fill this gap, we first use k -core decomposition on Class Dependency Networks to analyze software bug distribution from a new perspective. An interesting and widely existed tendency is observed: for classes in k -cores with larger k values, there is a stronger possibility for them to be buggy. Based on this observation, we then propose a simple but effective equation named as top-core which improves the order of classes in the suspicious class list produced by effort-aware bug prediction models. Based on an empirical study on 18 open-source Java systems, we show that the bug prediction models' performances are significantly improved in 85.2 percent experiments in the cross-validation scenario and in 80.95 percent experiments in the forward-release scenario, after using top-core . The models' average performances are improved by 11.5 and 12.6 percent, respectively. It is concluded that the proposed top-core equation can help the testers or code reviewers locate the real bugs more quickly and easily in software bug prediction practices.
doi_str_mv 10.1109/TSE.2019.2892959
format Article
fullrecord <record><control><sourceid>proquest_RIE</sourceid><recordid>TN_cdi_ieee_primary_8611396</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>8611396</ieee_id><sourcerecordid>2489082190</sourcerecordid><originalsourceid>FETCH-LOGICAL-c291t-8029e0edf391f7eb4dff34e89ccc4d6faceec27cc50303d3245f28c6ffebded3</originalsourceid><addsrcrecordid>eNo9kEFLAzEQhYMoWKt3wUvAg6etk2R3mxy1Vi1WLVjPyzaZlK27m5pslf57UyvCwMDjvZnHR8g5gwFjoK7nb-MBB6YGXCquMnVAekwJlYiMwyHpASiZZJlUx-QkhBUAZMNh1iPuPVTtkj4l2nmkd6hds3ah6irX0jijugwhymtsDbZ6S1-w-3b-I9DO0Umz9u4L6e1mSWceTaV_Y8_OYH0VolRGQZc1naG3zjdlq_GUHNmyDnj2t_tkfj-ejx6T6evDZHQzTTRXrEskcIWAxgrF7BAXqbFWpCiV1jo1uS01ouZDrTMQIIzgaWa51Lm1uDBoRJ9c7s_Ghp8bDF2xchvfxo8FT6UCyZmC6IK9S3sXgkdbrH3VlH5bMCh2VItItdhRLf6oxsjFPlIh4r9d5owJlYsfb9x1tw</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2489082190</pqid></control><display><type>article</type><title>Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance</title><source>IEEE Electronic Library (IEL)</source><creator>Qu, Yu ; Zheng, Qinghua ; Chi, Jianlei ; Jin, Yangxu ; He, Ancheng ; Cui, Di ; Zhang, Hengshan ; Liu, Ting</creator><creatorcontrib>Qu, Yu ; Zheng, Qinghua ; Chi, Jianlei ; Jin, Yangxu ; He, Ancheng ; Cui, Di ; Zhang, Hengshan ; Liu, Ting</creatorcontrib><description>In recent years, Complex Network theory and graph algorithms have been proved to be effective in predicting software bugs. On the other hand, as a widely-used algorithm in Complex Network theory, k-core decomposition has been used in software engineering domain to identify key classes. Intuitively, key classes are more likely to be buggy since they participate in more functions or have more interactions and dependencies. However, there is no existing research uses k -core decomposition to analyze software bugs. To fill this gap, we first use k -core decomposition on Class Dependency Networks to analyze software bug distribution from a new perspective. An interesting and widely existed tendency is observed: for classes in k -cores with larger k values, there is a stronger possibility for them to be buggy. Based on this observation, we then propose a simple but effective equation named as top-core which improves the order of classes in the suspicious class list produced by effort-aware bug prediction models. Based on an empirical study on 18 open-source Java systems, we show that the bug prediction models' performances are significantly improved in 85.2 percent experiments in the cross-validation scenario and in 80.95 percent experiments in the forward-release scenario, after using top-core . The models' average performances are improved by 11.5 and 12.6 percent, respectively. It is concluded that the proposed top-core equation can help the testers or code reviewers locate the real bugs more quickly and easily in software bug prediction practices.</description><identifier>ISSN: 0098-5589</identifier><identifier>EISSN: 1939-3520</identifier><identifier>DOI: 10.1109/TSE.2019.2892959</identifier><identifier>CODEN: IESEDJ</identifier><language>eng</language><publisher>New York: IEEE</publisher><subject>Algorithms ; Bug prediction ; class dependency network ; complex network ; Complex networks ; Computer bugs ; Debugging ; Decomposition ; Dependence ; effort-aware bug prediction ; Empirical analysis ; Mathematical model ; Performance prediction ; Prediction algorithms ; Prediction models ; Predictive models ; Software ; Software algorithms ; software defects ; Software engineering ; Source code</subject><ispartof>IEEE transactions on software engineering, 2021-02, Vol.47 (2), p.348-366</ispartof><rights>Copyright IEEE Computer Society 2021</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c291t-8029e0edf391f7eb4dff34e89ccc4d6faceec27cc50303d3245f28c6ffebded3</citedby><cites>FETCH-LOGICAL-c291t-8029e0edf391f7eb4dff34e89ccc4d6faceec27cc50303d3245f28c6ffebded3</cites><orcidid>0000-0002-1400-6740 ; 0000-0002-7600-0934</orcidid></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/8611396$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>314,780,784,796,27924,27925,54758</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/8611396$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Qu, Yu</creatorcontrib><creatorcontrib>Zheng, Qinghua</creatorcontrib><creatorcontrib>Chi, Jianlei</creatorcontrib><creatorcontrib>Jin, Yangxu</creatorcontrib><creatorcontrib>He, Ancheng</creatorcontrib><creatorcontrib>Cui, Di</creatorcontrib><creatorcontrib>Zhang, Hengshan</creatorcontrib><creatorcontrib>Liu, Ting</creatorcontrib><title>Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance</title><title>IEEE transactions on software engineering</title><addtitle>TSE</addtitle><description>In recent years, Complex Network theory and graph algorithms have been proved to be effective in predicting software bugs. On the other hand, as a widely-used algorithm in Complex Network theory, k-core decomposition has been used in software engineering domain to identify key classes. Intuitively, key classes are more likely to be buggy since they participate in more functions or have more interactions and dependencies. However, there is no existing research uses k -core decomposition to analyze software bugs. To fill this gap, we first use k -core decomposition on Class Dependency Networks to analyze software bug distribution from a new perspective. An interesting and widely existed tendency is observed: for classes in k -cores with larger k values, there is a stronger possibility for them to be buggy. Based on this observation, we then propose a simple but effective equation named as top-core which improves the order of classes in the suspicious class list produced by effort-aware bug prediction models. Based on an empirical study on 18 open-source Java systems, we show that the bug prediction models' performances are significantly improved in 85.2 percent experiments in the cross-validation scenario and in 80.95 percent experiments in the forward-release scenario, after using top-core . The models' average performances are improved by 11.5 and 12.6 percent, respectively. It is concluded that the proposed top-core equation can help the testers or code reviewers locate the real bugs more quickly and easily in software bug prediction practices.</description><subject>Algorithms</subject><subject>Bug prediction</subject><subject>class dependency network</subject><subject>complex network</subject><subject>Complex networks</subject><subject>Computer bugs</subject><subject>Debugging</subject><subject>Decomposition</subject><subject>Dependence</subject><subject>effort-aware bug prediction</subject><subject>Empirical analysis</subject><subject>Mathematical model</subject><subject>Performance prediction</subject><subject>Prediction algorithms</subject><subject>Prediction models</subject><subject>Predictive models</subject><subject>Software</subject><subject>Software algorithms</subject><subject>software defects</subject><subject>Software engineering</subject><subject>Source code</subject><issn>0098-5589</issn><issn>1939-3520</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2021</creationdate><recordtype>article</recordtype><sourceid>RIE</sourceid><recordid>eNo9kEFLAzEQhYMoWKt3wUvAg6etk2R3mxy1Vi1WLVjPyzaZlK27m5pslf57UyvCwMDjvZnHR8g5gwFjoK7nb-MBB6YGXCquMnVAekwJlYiMwyHpASiZZJlUx-QkhBUAZMNh1iPuPVTtkj4l2nmkd6hds3ah6irX0jijugwhymtsDbZ6S1-w-3b-I9DO0Umz9u4L6e1mSWceTaV_Y8_OYH0VolRGQZc1naG3zjdlq_GUHNmyDnj2t_tkfj-ejx6T6evDZHQzTTRXrEskcIWAxgrF7BAXqbFWpCiV1jo1uS01ouZDrTMQIIzgaWa51Lm1uDBoRJ9c7s_Ghp8bDF2xchvfxo8FT6UCyZmC6IK9S3sXgkdbrH3VlH5bMCh2VItItdhRLf6oxsjFPlIh4r9d5owJlYsfb9x1tw</recordid><startdate>20210201</startdate><enddate>20210201</enddate><creator>Qu, Yu</creator><creator>Zheng, Qinghua</creator><creator>Chi, Jianlei</creator><creator>Jin, Yangxu</creator><creator>He, Ancheng</creator><creator>Cui, Di</creator><creator>Zhang, Hengshan</creator><creator>Liu, Ting</creator><general>IEEE</general><general>IEEE Computer Society</general><scope>97E</scope><scope>RIA</scope><scope>RIE</scope><scope>AAYXX</scope><scope>CITATION</scope><scope>JQ2</scope><scope>K9.</scope><orcidid>https://orcid.org/0000-0002-1400-6740</orcidid><orcidid>https://orcid.org/0000-0002-7600-0934</orcidid></search><sort><creationdate>20210201</creationdate><title>Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance</title><author>Qu, Yu ; Zheng, Qinghua ; Chi, Jianlei ; Jin, Yangxu ; He, Ancheng ; Cui, Di ; Zhang, Hengshan ; Liu, Ting</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c291t-8029e0edf391f7eb4dff34e89ccc4d6faceec27cc50303d3245f28c6ffebded3</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2021</creationdate><topic>Algorithms</topic><topic>Bug prediction</topic><topic>class dependency network</topic><topic>complex network</topic><topic>Complex networks</topic><topic>Computer bugs</topic><topic>Debugging</topic><topic>Decomposition</topic><topic>Dependence</topic><topic>effort-aware bug prediction</topic><topic>Empirical analysis</topic><topic>Mathematical model</topic><topic>Performance prediction</topic><topic>Prediction algorithms</topic><topic>Prediction models</topic><topic>Predictive models</topic><topic>Software</topic><topic>Software algorithms</topic><topic>software defects</topic><topic>Software engineering</topic><topic>Source code</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Qu, Yu</creatorcontrib><creatorcontrib>Zheng, Qinghua</creatorcontrib><creatorcontrib>Chi, Jianlei</creatorcontrib><creatorcontrib>Jin, Yangxu</creatorcontrib><creatorcontrib>He, Ancheng</creatorcontrib><creatorcontrib>Cui, Di</creatorcontrib><creatorcontrib>Zhang, Hengshan</creatorcontrib><creatorcontrib>Liu, Ting</creatorcontrib><collection>IEEE All-Society Periodicals Package (ASPP) 2005-present</collection><collection>IEEE All-Society Periodicals Package (ASPP) 1998-Present</collection><collection>IEEE Electronic Library (IEL)</collection><collection>CrossRef</collection><collection>ProQuest Computer Science Collection</collection><collection>ProQuest Health &amp; Medical Complete (Alumni)</collection><jtitle>IEEE transactions on software engineering</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Qu, Yu</au><au>Zheng, Qinghua</au><au>Chi, Jianlei</au><au>Jin, Yangxu</au><au>He, Ancheng</au><au>Cui, Di</au><au>Zhang, Hengshan</au><au>Liu, Ting</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance</atitle><jtitle>IEEE transactions on software engineering</jtitle><stitle>TSE</stitle><date>2021-02-01</date><risdate>2021</risdate><volume>47</volume><issue>2</issue><spage>348</spage><epage>366</epage><pages>348-366</pages><issn>0098-5589</issn><eissn>1939-3520</eissn><coden>IESEDJ</coden><abstract>In recent years, Complex Network theory and graph algorithms have been proved to be effective in predicting software bugs. On the other hand, as a widely-used algorithm in Complex Network theory, k-core decomposition has been used in software engineering domain to identify key classes. Intuitively, key classes are more likely to be buggy since they participate in more functions or have more interactions and dependencies. However, there is no existing research uses k -core decomposition to analyze software bugs. To fill this gap, we first use k -core decomposition on Class Dependency Networks to analyze software bug distribution from a new perspective. An interesting and widely existed tendency is observed: for classes in k -cores with larger k values, there is a stronger possibility for them to be buggy. Based on this observation, we then propose a simple but effective equation named as top-core which improves the order of classes in the suspicious class list produced by effort-aware bug prediction models. Based on an empirical study on 18 open-source Java systems, we show that the bug prediction models' performances are significantly improved in 85.2 percent experiments in the cross-validation scenario and in 80.95 percent experiments in the forward-release scenario, after using top-core . The models' average performances are improved by 11.5 and 12.6 percent, respectively. It is concluded that the proposed top-core equation can help the testers or code reviewers locate the real bugs more quickly and easily in software bug prediction practices.</abstract><cop>New York</cop><pub>IEEE</pub><doi>10.1109/TSE.2019.2892959</doi><tpages>19</tpages><orcidid>https://orcid.org/0000-0002-1400-6740</orcidid><orcidid>https://orcid.org/0000-0002-7600-0934</orcidid></addata></record>
fulltext fulltext_linktorsrc
identifier ISSN: 0098-5589
ispartof IEEE transactions on software engineering, 2021-02, Vol.47 (2), p.348-366
issn 0098-5589
1939-3520
language eng
recordid cdi_ieee_primary_8611396
source IEEE Electronic Library (IEL)
subjects Algorithms
Bug prediction
class dependency network
complex network
Complex networks
Computer bugs
Debugging
Decomposition
Dependence
effort-aware bug prediction
Empirical analysis
Mathematical model
Performance prediction
Prediction algorithms
Prediction models
Predictive models
Software
Software algorithms
software defects
Software engineering
Source code
title Using K-core Decomposition on Class Dependency Networks to Improve Bug Prediction Model's Practical Performance
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-02T17%3A21%3A57IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_RIE&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Using%20K-core%20Decomposition%20on%20Class%20Dependency%20Networks%20to%20Improve%20Bug%20Prediction%20Model's%20Practical%20Performance&rft.jtitle=IEEE%20transactions%20on%20software%20engineering&rft.au=Qu,%20Yu&rft.date=2021-02-01&rft.volume=47&rft.issue=2&rft.spage=348&rft.epage=366&rft.pages=348-366&rft.issn=0098-5589&rft.eissn=1939-3520&rft.coden=IESEDJ&rft_id=info:doi/10.1109/TSE.2019.2892959&rft_dat=%3Cproquest_RIE%3E2489082190%3C/proquest_RIE%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=2489082190&rft_id=info:pmid/&rft_ieee_id=8611396&rfr_iscdi=true