Experiences with the Design of a Run-Time Check

Run-time checks are often assumed to be a cost-effective way of improving the dependability of software components, by checking required properties of their outputs and flagging an output as incorrect if it fails the check. Run-time checks’ main point of attractiveness is that they are supposed to b...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: van der Meulen, Meine J. P., Revilla, Miguel A.
Format: Tagungsbericht
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 315
container_issue
container_start_page 302
container_title
container_volume
creator van der Meulen, Meine J. P.
Revilla, Miguel A.
description Run-time checks are often assumed to be a cost-effective way of improving the dependability of software components, by checking required properties of their outputs and flagging an output as incorrect if it fails the check. Run-time checks’ main point of attractiveness is that they are supposed to be easy to implement. Also, they are implicitly assumed to be effective in detecting incorrect outputs. This paper reports the results of an experiment designed to challenge these assumptions about run-time checks. The experiment uses a subset of 196 of 867 programs (primaries) solving a problem called “Make Palindrome”. This is an existing problem on the “On-Line Judge” website of the university of Valladolid. We formulated eight run-time checks, and posted this problem on the same web-site. This resulted in 335 programs (checkers) implementing the run-time checks, 115 of which are used for the experiment. In this experiment: (1) the effectiveness of the population of possibly faulty checkers is very close to the effectiveness of a correct checker; (2) the reliability improvement provided by the run-time checks is relatively small, between a factor of one and three; (3) The reliability improvement gained by using multiple-version redundancy is much higher. Given the fact that this experiment only considers one primary/Run-Time Check combination, it is not yet possible to generalise the results.
doi_str_mv 10.1007/11875567_23
format Conference Proceeding
fullrecord <record><control><sourceid>pascalfrancis_sprin</sourceid><recordid>TN_cdi_pascalfrancis_primary_20395146</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>20395146</sourcerecordid><originalsourceid>FETCH-LOGICAL-p219t-94411aabd0dea79bace0d9ab742c9ae52196014379c265d279fd38004ef256cb3</originalsourceid><addsrcrecordid>eNpNkDtPwzAUhc1LopRO_AEvDAyh9_r6UY-oLQ-pEhIqs-U4ThvaplEcBPx7gooEZznD-XSGj7ErhFsEMGPEiVFKGyfoiF2QkiCV0YTHbIAaMSOS9uRvEHTKBkAgMmsknbNRSm_Qh1BPLA7YeP7ZxLaKdYiJf1TdmnfryGcxVaua70vu-ct7nS2rXeTTdQybS3ZW-m2Ko98estf7-XL6mC2eH56md4usEWi7zEqJ6H1eQBG9sbkPEQrrcyNFsD6qHtKAkowNQqtCGFsWNAGQsRRKh5yG7Prw2_gU_LZsfR2q5Jq22vn2ywkgq1Dqnrs5cKmf6lVsXb7fb5JDcD-63D9d9A3rKlVS</addsrcrecordid><sourcetype>Index Database</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Experiences with the Design of a Run-Time Check</title><source>Springer Books</source><creator>van der Meulen, Meine J. P. ; Revilla, Miguel A.</creator><contributor>Górski, Janusz</contributor><creatorcontrib>van der Meulen, Meine J. P. ; Revilla, Miguel A. ; Górski, Janusz</creatorcontrib><description>Run-time checks are often assumed to be a cost-effective way of improving the dependability of software components, by checking required properties of their outputs and flagging an output as incorrect if it fails the check. Run-time checks’ main point of attractiveness is that they are supposed to be easy to implement. Also, they are implicitly assumed to be effective in detecting incorrect outputs. This paper reports the results of an experiment designed to challenge these assumptions about run-time checks. The experiment uses a subset of 196 of 867 programs (primaries) solving a problem called “Make Palindrome”. This is an existing problem on the “On-Line Judge” website of the university of Valladolid. We formulated eight run-time checks, and posted this problem on the same web-site. This resulted in 335 programs (checkers) implementing the run-time checks, 115 of which are used for the experiment. In this experiment: (1) the effectiveness of the population of possibly faulty checkers is very close to the effectiveness of a correct checker; (2) the reliability improvement provided by the run-time checks is relatively small, between a factor of one and three; (3) The reliability improvement gained by using multiple-version redundancy is much higher. Given the fact that this experiment only considers one primary/Run-Time Check combination, it is not yet possible to generalise the results.</description><identifier>ISSN: 0302-9743</identifier><identifier>ISBN: 3540457623</identifier><identifier>ISBN: 9783540457626</identifier><identifier>EISSN: 1611-3349</identifier><identifier>EISBN: 3540457631</identifier><identifier>EISBN: 9783540457633</identifier><identifier>DOI: 10.1007/11875567_23</identifier><language>eng</language><publisher>Berlin, Heidelberg: Springer Berlin Heidelberg</publisher><subject>Applied sciences ; Computer science; control theory; systems ; Exact sciences and technology ; Software ; Software engineering</subject><ispartof>Computer Safety, Reliability, and Security, 2006, p.302-315</ispartof><rights>Springer-Verlag Berlin Heidelberg 2006</rights><rights>2008 INIST-CNRS</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktopdf>$$Uhttps://link.springer.com/content/pdf/10.1007/11875567_23$$EPDF$$P50$$Gspringer$$H</linktopdf><linktohtml>$$Uhttps://link.springer.com/10.1007/11875567_23$$EHTML$$P50$$Gspringer$$H</linktohtml><link.rule.ids>309,310,775,776,780,785,786,789,4036,4037,27902,38232,41418,42487</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&amp;idt=20395146$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><contributor>Górski, Janusz</contributor><creatorcontrib>van der Meulen, Meine J. P.</creatorcontrib><creatorcontrib>Revilla, Miguel A.</creatorcontrib><title>Experiences with the Design of a Run-Time Check</title><title>Computer Safety, Reliability, and Security</title><description>Run-time checks are often assumed to be a cost-effective way of improving the dependability of software components, by checking required properties of their outputs and flagging an output as incorrect if it fails the check. Run-time checks’ main point of attractiveness is that they are supposed to be easy to implement. Also, they are implicitly assumed to be effective in detecting incorrect outputs. This paper reports the results of an experiment designed to challenge these assumptions about run-time checks. The experiment uses a subset of 196 of 867 programs (primaries) solving a problem called “Make Palindrome”. This is an existing problem on the “On-Line Judge” website of the university of Valladolid. We formulated eight run-time checks, and posted this problem on the same web-site. This resulted in 335 programs (checkers) implementing the run-time checks, 115 of which are used for the experiment. In this experiment: (1) the effectiveness of the population of possibly faulty checkers is very close to the effectiveness of a correct checker; (2) the reliability improvement provided by the run-time checks is relatively small, between a factor of one and three; (3) The reliability improvement gained by using multiple-version redundancy is much higher. Given the fact that this experiment only considers one primary/Run-Time Check combination, it is not yet possible to generalise the results.</description><subject>Applied sciences</subject><subject>Computer science; control theory; systems</subject><subject>Exact sciences and technology</subject><subject>Software</subject><subject>Software engineering</subject><issn>0302-9743</issn><issn>1611-3349</issn><isbn>3540457623</isbn><isbn>9783540457626</isbn><isbn>3540457631</isbn><isbn>9783540457633</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2006</creationdate><recordtype>conference_proceeding</recordtype><recordid>eNpNkDtPwzAUhc1LopRO_AEvDAyh9_r6UY-oLQ-pEhIqs-U4ThvaplEcBPx7gooEZznD-XSGj7ErhFsEMGPEiVFKGyfoiF2QkiCV0YTHbIAaMSOS9uRvEHTKBkAgMmsknbNRSm_Qh1BPLA7YeP7ZxLaKdYiJf1TdmnfryGcxVaua70vu-ct7nS2rXeTTdQybS3ZW-m2Ko98estf7-XL6mC2eH56md4usEWi7zEqJ6H1eQBG9sbkPEQrrcyNFsD6qHtKAkowNQqtCGFsWNAGQsRRKh5yG7Prw2_gU_LZsfR2q5Jq22vn2ywkgq1Dqnrs5cKmf6lVsXb7fb5JDcD-63D9d9A3rKlVS</recordid><startdate>2006</startdate><enddate>2006</enddate><creator>van der Meulen, Meine J. P.</creator><creator>Revilla, Miguel A.</creator><general>Springer Berlin Heidelberg</general><general>Springer</general><scope>IQODW</scope></search><sort><creationdate>2006</creationdate><title>Experiences with the Design of a Run-Time Check</title><author>van der Meulen, Meine J. P. ; Revilla, Miguel A.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-p219t-94411aabd0dea79bace0d9ab742c9ae52196014379c265d279fd38004ef256cb3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2006</creationdate><topic>Applied sciences</topic><topic>Computer science; control theory; systems</topic><topic>Exact sciences and technology</topic><topic>Software</topic><topic>Software engineering</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>van der Meulen, Meine J. P.</creatorcontrib><creatorcontrib>Revilla, Miguel A.</creatorcontrib><collection>Pascal-Francis</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>van der Meulen, Meine J. P.</au><au>Revilla, Miguel A.</au><au>Górski, Janusz</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Experiences with the Design of a Run-Time Check</atitle><btitle>Computer Safety, Reliability, and Security</btitle><date>2006</date><risdate>2006</risdate><spage>302</spage><epage>315</epage><pages>302-315</pages><issn>0302-9743</issn><eissn>1611-3349</eissn><isbn>3540457623</isbn><isbn>9783540457626</isbn><eisbn>3540457631</eisbn><eisbn>9783540457633</eisbn><abstract>Run-time checks are often assumed to be a cost-effective way of improving the dependability of software components, by checking required properties of their outputs and flagging an output as incorrect if it fails the check. Run-time checks’ main point of attractiveness is that they are supposed to be easy to implement. Also, they are implicitly assumed to be effective in detecting incorrect outputs. This paper reports the results of an experiment designed to challenge these assumptions about run-time checks. The experiment uses a subset of 196 of 867 programs (primaries) solving a problem called “Make Palindrome”. This is an existing problem on the “On-Line Judge” website of the university of Valladolid. We formulated eight run-time checks, and posted this problem on the same web-site. This resulted in 335 programs (checkers) implementing the run-time checks, 115 of which are used for the experiment. In this experiment: (1) the effectiveness of the population of possibly faulty checkers is very close to the effectiveness of a correct checker; (2) the reliability improvement provided by the run-time checks is relatively small, between a factor of one and three; (3) The reliability improvement gained by using multiple-version redundancy is much higher. Given the fact that this experiment only considers one primary/Run-Time Check combination, it is not yet possible to generalise the results.</abstract><cop>Berlin, Heidelberg</cop><pub>Springer Berlin Heidelberg</pub><doi>10.1007/11875567_23</doi><tpages>14</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0302-9743
ispartof Computer Safety, Reliability, and Security, 2006, p.302-315
issn 0302-9743
1611-3349
language eng
recordid cdi_pascalfrancis_primary_20395146
source Springer Books
subjects Applied sciences
Computer science
control theory
systems
Exact sciences and technology
Software
Software engineering
title Experiences with the Design of a Run-Time Check
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-30T17%3A32%3A31IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-pascalfrancis_sprin&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Experiences%20with%20the%20Design%20of%20a%20Run-Time%20Check&rft.btitle=Computer%20Safety,%20Reliability,%20and%20Security&rft.au=van%20der%20Meulen,%20Meine%20J.%20P.&rft.date=2006&rft.spage=302&rft.epage=315&rft.pages=302-315&rft.issn=0302-9743&rft.eissn=1611-3349&rft.isbn=3540457623&rft.isbn_list=9783540457626&rft_id=info:doi/10.1007/11875567_23&rft_dat=%3Cpascalfrancis_sprin%3E20395146%3C/pascalfrancis_sprin%3E%3Curl%3E%3C/url%3E&rft.eisbn=3540457631&rft.eisbn_list=9783540457633&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true