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,...
Gespeichert in:
Veröffentlicht in: | IEEE transactions on software engineering 2021-02, Vol.47 (2), p.348-366 |
---|---|
Hauptverfasser: | , , , , , , , |
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 & 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 |