Deriving a fault architecture from defect history
As software systems mature, there is the danger that not only code decays, but software architectures as well. We adapt a reverse architecting technique to defect reports of a series of releases. Relationships among system components are identified based on whether they are involved in the same defe...
Gespeichert in:
| Hauptverfasser: | , , , |
|---|---|
| Format: | Tagungsbericht |
| Sprache: | eng |
| Schlagworte: | |
| Online-Zugang: | Volltext bestellen |
| Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
| container_end_page | 303 |
|---|---|
| container_issue | |
| container_start_page | 295 |
| container_title | |
| container_volume | |
| creator | von Mayrhauser, A. Wang, J. Ohlsson, M.C. Wohlin, C. |
| description | As software systems mature, there is the danger that not only code decays, but software architectures as well. We adapt a reverse architecting technique to defect reports of a series of releases. Relationships among system components are identified based on whether they are involved in the same defect report, and for how many defect reports this occurs. There are degrees of fault-coupling between components depending on how often two components are involved in a defect fix. After these fault-coupling relationships between components are extracted, they are abstracted to the subsystem level. The resulting fault architecture figures show for each release what its most fault-prone relationships are. Comparing across releases shows whether some relationships between components are repeatedly fault prone, indicating an underlying systemic architecture problem. We illustrate our technique on a large commercial system consisting of over 800 KLOC of C, C++, and microcode. |
| doi_str_mv | 10.1109/ISSRE.1999.809335 |
| format | Conference Proceeding |
| fullrecord | <record><control><sourceid>proquest_6IE</sourceid><recordid>TN_cdi_ieee_primary_809335</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>809335</ieee_id><sourcerecordid>26918226</sourcerecordid><originalsourceid>FETCH-LOGICAL-i118t-f200d2d4b604f4e191a96e220fac0e294d1164e57022302f40f6fec11e098a883</originalsourceid><addsrcrecordid>eNotkM1Lw0AUxBc_wFL7B-gpJ2-p7-1X9h2lVi0UBKvnsCZv7Ura1E0i9L83UOcyDPyYgRHiBmGOCHS_2mzelnMkorkDUsqciYlUSubWaDoXMyocFJYMaK3chZggFJiTNu5KzLruG0YZ45xRE4GPnOJv3H9lPgt-aPrMp2obe676IXEWUrvLag5jzLax69t0vBaXwTcdz_59Kj6elu-Ll3z9-rxaPKzziOj6PEiAWtb604IOmpHQk2UpIfgKWJKuEa1mU4CUCmTQEOw4g8hAzjunpuLu1HtI7c_AXV_uYldx0_g9t0NXSkvopLQjeHsCIzOXhxR3Ph3L0zHqD9s1U0Y</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype><pqid>26918226</pqid></control><display><type>conference_proceeding</type><title>Deriving a fault architecture from defect history</title><source>IEEE Electronic Library (IEL) Conference Proceedings</source><creator>von Mayrhauser, A. ; Wang, J. ; Ohlsson, M.C. ; Wohlin, C.</creator><creatorcontrib>von Mayrhauser, A. ; Wang, J. ; Ohlsson, M.C. ; Wohlin, C.</creatorcontrib><description>As software systems mature, there is the danger that not only code decays, but software architectures as well. We adapt a reverse architecting technique to defect reports of a series of releases. Relationships among system components are identified based on whether they are involved in the same defect report, and for how many defect reports this occurs. There are degrees of fault-coupling between components depending on how often two components are involved in a defect fix. After these fault-coupling relationships between components are extracted, they are abstracted to the subsystem level. The resulting fault architecture figures show for each release what its most fault-prone relationships are. Comparing across releases shows whether some relationships between components are repeatedly fault prone, indicating an underlying systemic architecture problem. We illustrate our technique on a large commercial system consisting of over 800 KLOC of C, C++, and microcode.</description><identifier>ISSN: 1071-9458</identifier><identifier>ISBN: 9780769504438</identifier><identifier>ISBN: 0769504434</identifier><identifier>EISSN: 2332-6549</identifier><identifier>DOI: 10.1109/ISSRE.1999.809335</identifier><language>eng</language><publisher>IEEE</publisher><subject>Arc discharges ; Buildings ; Computer architecture ; Computer science ; Degradation ; Electrical capacitance tomography ; Fault diagnosis ; Hip ; History ; Software architecture</subject><ispartof>Proceedings - International Symposium on Software Reliability Engineering, 1999, p.295-303</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/809335$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,780,784,789,790,2058,4050,4051,27925,54920</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/809335$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>von Mayrhauser, A.</creatorcontrib><creatorcontrib>Wang, J.</creatorcontrib><creatorcontrib>Ohlsson, M.C.</creatorcontrib><creatorcontrib>Wohlin, C.</creatorcontrib><title>Deriving a fault architecture from defect history</title><title>Proceedings - International Symposium on Software Reliability Engineering</title><addtitle>ISSRE</addtitle><description>As software systems mature, there is the danger that not only code decays, but software architectures as well. We adapt a reverse architecting technique to defect reports of a series of releases. Relationships among system components are identified based on whether they are involved in the same defect report, and for how many defect reports this occurs. There are degrees of fault-coupling between components depending on how often two components are involved in a defect fix. After these fault-coupling relationships between components are extracted, they are abstracted to the subsystem level. The resulting fault architecture figures show for each release what its most fault-prone relationships are. Comparing across releases shows whether some relationships between components are repeatedly fault prone, indicating an underlying systemic architecture problem. We illustrate our technique on a large commercial system consisting of over 800 KLOC of C, C++, and microcode.</description><subject>Arc discharges</subject><subject>Buildings</subject><subject>Computer architecture</subject><subject>Computer science</subject><subject>Degradation</subject><subject>Electrical capacitance tomography</subject><subject>Fault diagnosis</subject><subject>Hip</subject><subject>History</subject><subject>Software architecture</subject><issn>1071-9458</issn><issn>2332-6549</issn><isbn>9780769504438</isbn><isbn>0769504434</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>1999</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><sourceid>RIE</sourceid><recordid>eNotkM1Lw0AUxBc_wFL7B-gpJ2-p7-1X9h2lVi0UBKvnsCZv7Ura1E0i9L83UOcyDPyYgRHiBmGOCHS_2mzelnMkorkDUsqciYlUSubWaDoXMyocFJYMaK3chZggFJiTNu5KzLruG0YZ45xRE4GPnOJv3H9lPgt-aPrMp2obe676IXEWUrvLag5jzLax69t0vBaXwTcdz_59Kj6elu-Ll3z9-rxaPKzziOj6PEiAWtb604IOmpHQk2UpIfgKWJKuEa1mU4CUCmTQEOw4g8hAzjunpuLu1HtI7c_AXV_uYldx0_g9t0NXSkvopLQjeHsCIzOXhxR3Ph3L0zHqD9s1U0Y</recordid><startdate>1999</startdate><enddate>1999</enddate><creator>von Mayrhauser, A.</creator><creator>Wang, J.</creator><creator>Ohlsson, M.C.</creator><creator>Wohlin, C.</creator><general>IEEE</general><scope>6IE</scope><scope>6IL</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIL</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope></search><sort><creationdate>1999</creationdate><title>Deriving a fault architecture from defect history</title><author>von Mayrhauser, A. ; Wang, J. ; Ohlsson, M.C. ; Wohlin, C.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i118t-f200d2d4b604f4e191a96e220fac0e294d1164e57022302f40f6fec11e098a883</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>1999</creationdate><topic>Arc discharges</topic><topic>Buildings</topic><topic>Computer architecture</topic><topic>Computer science</topic><topic>Degradation</topic><topic>Electrical capacitance tomography</topic><topic>Fault diagnosis</topic><topic>Hip</topic><topic>History</topic><topic>Software architecture</topic><toplevel>online_resources</toplevel><creatorcontrib>von Mayrhauser, A.</creatorcontrib><creatorcontrib>Wang, J.</creatorcontrib><creatorcontrib>Ohlsson, M.C.</creatorcontrib><creatorcontrib>Wohlin, C.</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan All Online (POP All Online) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP All) 1998-Present</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></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>von Mayrhauser, A.</au><au>Wang, J.</au><au>Ohlsson, M.C.</au><au>Wohlin, C.</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Deriving a fault architecture from defect history</atitle><btitle>Proceedings - International Symposium on Software Reliability Engineering</btitle><stitle>ISSRE</stitle><date>1999</date><risdate>1999</risdate><spage>295</spage><epage>303</epage><pages>295-303</pages><issn>1071-9458</issn><eissn>2332-6549</eissn><isbn>9780769504438</isbn><isbn>0769504434</isbn><abstract>As software systems mature, there is the danger that not only code decays, but software architectures as well. We adapt a reverse architecting technique to defect reports of a series of releases. Relationships among system components are identified based on whether they are involved in the same defect report, and for how many defect reports this occurs. There are degrees of fault-coupling between components depending on how often two components are involved in a defect fix. After these fault-coupling relationships between components are extracted, they are abstracted to the subsystem level. The resulting fault architecture figures show for each release what its most fault-prone relationships are. Comparing across releases shows whether some relationships between components are repeatedly fault prone, indicating an underlying systemic architecture problem. We illustrate our technique on a large commercial system consisting of over 800 KLOC of C, C++, and microcode.</abstract><pub>IEEE</pub><doi>10.1109/ISSRE.1999.809335</doi><tpages>9</tpages></addata></record> |
| fulltext | fulltext_linktorsrc |
| identifier | ISSN: 1071-9458 |
| ispartof | Proceedings - International Symposium on Software Reliability Engineering, 1999, p.295-303 |
| issn | 1071-9458 2332-6549 |
| language | eng |
| recordid | cdi_ieee_primary_809335 |
| source | IEEE Electronic Library (IEL) Conference Proceedings |
| subjects | Arc discharges Buildings Computer architecture Computer science Degradation Electrical capacitance tomography Fault diagnosis Hip History Software architecture |
| title | Deriving a fault architecture from defect history |
| url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-29T09%3A04%3A00IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_6IE&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Deriving%20a%20fault%20architecture%20from%20defect%20history&rft.btitle=Proceedings%20-%20International%20Symposium%20on%20Software%20Reliability%20Engineering&rft.au=von%20Mayrhauser,%20A.&rft.date=1999&rft.spage=295&rft.epage=303&rft.pages=295-303&rft.issn=1071-9458&rft.eissn=2332-6549&rft.isbn=9780769504438&rft.isbn_list=0769504434&rft_id=info:doi/10.1109/ISSRE.1999.809335&rft_dat=%3Cproquest_6IE%3E26918226%3C/proquest_6IE%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=26918226&rft_id=info:pmid/&rft_ieee_id=809335&rfr_iscdi=true |