Home > Research > Publications & Outputs > Analyzing the Effects of Bugs on Software Inter...

Links

Text available via DOI:

View graph of relations

Analyzing the Effects of Bugs on Software Interfaces

Research output: Contribution to Journal/MagazineJournal articlepeer-review

Published

Standard

Analyzing the Effects of Bugs on Software Interfaces. / Natella, R.; Winter, S.; Cotroneo, D. et al.

In: IEEE Transactions on Software Engineering, Vol. 46, No. 3, 01.03.2020, p. 280-301.

Research output: Contribution to Journal/MagazineJournal articlepeer-review

Harvard

Natella, R, Winter, S, Cotroneo, D & Suri, N 2020, 'Analyzing the Effects of Bugs on Software Interfaces', IEEE Transactions on Software Engineering, vol. 46, no. 3, pp. 280-301. https://doi.org/10.1109/TSE.2018.2850755

APA

Natella, R., Winter, S., Cotroneo, D., & Suri, N. (2020). Analyzing the Effects of Bugs on Software Interfaces. IEEE Transactions on Software Engineering, 46(3), 280-301. https://doi.org/10.1109/TSE.2018.2850755

Vancouver

Natella R, Winter S, Cotroneo D, Suri N. Analyzing the Effects of Bugs on Software Interfaces. IEEE Transactions on Software Engineering. 2020 Mar 1;46(3):280-301. Epub 2018 Jun 26. doi: 10.1109/TSE.2018.2850755

Author

Natella, R. ; Winter, S. ; Cotroneo, D. et al. / Analyzing the Effects of Bugs on Software Interfaces. In: IEEE Transactions on Software Engineering. 2020 ; Vol. 46, No. 3. pp. 280-301.

Bibtex

@article{bcc5cc55da374267864abfb991fe930e,
title = "Analyzing the Effects of Bugs on Software Interfaces",
abstract = "Critical systems that integrate software components (e.g., from third-parties) need to address the risk of residual software defects in these components. Software fault injection is an experimental solution to gauge such risk. Many error models have been proposed for emulating faulty components, such as by injecting error codes and exceptions, or by corrupting data with bit-flips, boundary values, and random values. Even if these error models have been able to find breaches in fragile systems, it is unclear whether these errors are in fact representative of software faults. To pursue this open question, we propose a methodology to analyze how software faults in $C/C_{++}$ software components turn into errors at components' interfaces (interface error propagation), and present an experimental analysis on what, where, and when to inject interface errors. The results point out that the traditional error models, as used so far, do not accurately emulate software faults, but that richer interface errors need to be injected, by: injecting both fail-stop behaviors and data corruptions; targeting larger amounts of corrupted data structures; emulating silent data corruptions not signaled by the component; combining bit-flips, boundary values, and data perturbations. IEEE",
keywords = "Computer bugs, Dependability, Error Models, Error Propagation, Fault Injection, Fault tolerance, Perturbation methods, Software, Software Components, Software Fault Tolerance, Testing, Unified modeling language, Computer software, Errors, Fault tolerant computer systems, Perturbation techniques, Software testing, Unified Modeling Language, Error model, Error propagation, Fault injection, Perturbation method, Software component, Software fault tolerances, Program debugging",
author = "R. Natella and S. Winter and D. Cotroneo and Neeraj Suri",
year = "2020",
month = mar,
day = "1",
doi = "10.1109/TSE.2018.2850755",
language = "English",
volume = "46",
pages = "280--301",
journal = "IEEE Transactions on Software Engineering",
issn = "0098-5589",
publisher = "Institute of Electrical and Electronics Engineers Inc.",
number = "3",

}

RIS

TY - JOUR

T1 - Analyzing the Effects of Bugs on Software Interfaces

AU - Natella, R.

AU - Winter, S.

AU - Cotroneo, D.

AU - Suri, Neeraj

PY - 2020/3/1

Y1 - 2020/3/1

N2 - Critical systems that integrate software components (e.g., from third-parties) need to address the risk of residual software defects in these components. Software fault injection is an experimental solution to gauge such risk. Many error models have been proposed for emulating faulty components, such as by injecting error codes and exceptions, or by corrupting data with bit-flips, boundary values, and random values. Even if these error models have been able to find breaches in fragile systems, it is unclear whether these errors are in fact representative of software faults. To pursue this open question, we propose a methodology to analyze how software faults in $C/C_{++}$ software components turn into errors at components' interfaces (interface error propagation), and present an experimental analysis on what, where, and when to inject interface errors. The results point out that the traditional error models, as used so far, do not accurately emulate software faults, but that richer interface errors need to be injected, by: injecting both fail-stop behaviors and data corruptions; targeting larger amounts of corrupted data structures; emulating silent data corruptions not signaled by the component; combining bit-flips, boundary values, and data perturbations. IEEE

AB - Critical systems that integrate software components (e.g., from third-parties) need to address the risk of residual software defects in these components. Software fault injection is an experimental solution to gauge such risk. Many error models have been proposed for emulating faulty components, such as by injecting error codes and exceptions, or by corrupting data with bit-flips, boundary values, and random values. Even if these error models have been able to find breaches in fragile systems, it is unclear whether these errors are in fact representative of software faults. To pursue this open question, we propose a methodology to analyze how software faults in $C/C_{++}$ software components turn into errors at components' interfaces (interface error propagation), and present an experimental analysis on what, where, and when to inject interface errors. The results point out that the traditional error models, as used so far, do not accurately emulate software faults, but that richer interface errors need to be injected, by: injecting both fail-stop behaviors and data corruptions; targeting larger amounts of corrupted data structures; emulating silent data corruptions not signaled by the component; combining bit-flips, boundary values, and data perturbations. IEEE

KW - Computer bugs

KW - Dependability

KW - Error Models

KW - Error Propagation

KW - Fault Injection

KW - Fault tolerance

KW - Perturbation methods

KW - Software

KW - Software Components

KW - Software Fault Tolerance

KW - Testing

KW - Unified modeling language

KW - Computer software

KW - Errors

KW - Fault tolerant computer systems

KW - Perturbation techniques

KW - Software testing

KW - Unified Modeling Language

KW - Error model

KW - Error propagation

KW - Fault injection

KW - Perturbation method

KW - Software component

KW - Software fault tolerances

KW - Program debugging

U2 - 10.1109/TSE.2018.2850755

DO - 10.1109/TSE.2018.2850755

M3 - Journal article

VL - 46

SP - 280

EP - 301

JO - IEEE Transactions on Software Engineering

JF - IEEE Transactions on Software Engineering

SN - 0098-5589

IS - 3

ER -