Robustness (computer science): Difference between revisions

Revision as of 06:44, 28 September 2019

Revision as of 09:21, 11 December 2019

Line 1:

{{see also|Fault-tolerant computer system}}

{{Complex systems}}

In [[computer science]], '''robustness''' is the ability of a computer system to cope with errors during execution<ref>{{cite web|url=http://dl.ifip.org/db/conf/pts/testcom2005/FernandezMP05.pdf |title=A Model-Based Approach for Robustness Testing |website=Dl.ifip.org |format=PDF |date= |accessdate=2016-11-13}}</ref><ref name="IEEE">1990. IEEE Standard Glossary of Software Engineering Terminology, IEEE Std 610.12-1990 defines robustness as "The degree to which a system or component can function correctly in the presence of invalid inputs or stressful environmental conditions"</ref> and cope with erroneous input.<ref name="IEEE"/> Robustness can encompass many areas of computer science, such as [[Defensive programming|robust programming]], [[Overfitting|robust machine learning]], and [[Robust Security Network]]. Formal techniques, such as [[fuzz testing]], are essential to showing robustness since this type of testing involves invalid or unexpected inputs. Alternatively, [[fault injection]] can be used to test robustness. Various commercial products perform robustness testing of software analysis.<ref>{{cite webjournal|url=http://www.stanford.edu/~bakerjw/Publications/Baker%20et%20al%20(2008)%20Robustness,%20Structural%20Safety.pdf |title=doi:10.1016/j.strusafe.2006.11.004 |website=Stanford.edu |format=PDF |date= |accessdate=2016-11-13|doi=10.1016/j.strusafe.2006.11.004 }}</ref>

== Introduction ==

In general, building robust systems that encompass every point of possible failure is difficult because of the vast quantity of possible inputs and input combinations.<ref name="MIT">{{cite web|url=http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf |format=PDF |title=Building Robust Systems an essay |author=Gerald Jay Sussman |date=January 13, 2007 |website=Groups.csail.mit.edu |accessdate=2016-11-13}}</ref> Since all inputs and input combinations would require too much time to test, developers cannot run through all cases exhaustively. Instead, the developer will try to generalize such cases.<ref>{{cite web|last=Joseph |first=Joby |url=http://www.softwaretestingclub.com/profiles/blogs/importance-of-making |title=Importance of Making Generalized Testcases - Software Testing Club - An Online Software Testing Community |publisher=Software Testing Club |date=2009-09-21 |accessdate=2016-11-13}}</ref> For example, imagine inputting some [[Integer (computer science)|integer values]]. Some selected inputs might consist of a negative number, zero, and a positive number. When using these numbers to test software in this way, the developer generalizes the set of all reals into three numbers. This is a more efficient and manageable method, but more prone to failure. Generalizing test cases is an example of just one technique to deal with failure—specifically, failure due to invalid user input. Systems generally may also fail due to other reasons as well, such as disconnecting from a network.

Regardless, complex systems should still handle any errors encountered gracefully. There are many examples of such successful systems. Some of the most robust systems are evolvable and can be easily adapted to new situations.<ref name="MIT" />

Line 10:

== Challenges ==

Programs and software are tools focused on a very specific task, and thus aren't generalized and flexible.<ref name="MIT" /> However, observations in systems such as the [[internet]] or [[biological system]]s demonstrate adaptation to their environments. One of the ways biological systems adapt to environments is through the use of redundancy.<ref name="MIT" /> Many organs are redundant in humans. The [[kidney]] is one such example. [[Human]]s generally only need one kidney, but having a second kidney allows room for failure. This same principle may be taken to apply to software, but there are some challenges.

When applying the principle of redundancy to computer science, blindly adding code is not suggested. Blindly adding code introduces more errors, makes the system more complex, and renders it harder to understand.<ref>{{cite web|url=http://www.cse.sc.edu/~huhns/journalpapers/V6N2.pdf |format=PDF |title=Building Robust Systems an essay |author=Agents on the wEb : Robust Software |website=Cse.sc.edu |accessdate=2016-11-13}}</ref> Code that doesn't provide any reinforcement to the already existing code is unwanted. The new code must instead possess equivalent [[function (engineering)|functionality]], so that if a function is broken, another providing the same function can replace it, using manual or automated [[software diversity]]. To do so, the new code must know how and when to accommodate the failure point.<ref name="MIT" /> This means more [[logic]] needs to be added to the system. But as a system adds more logic, [[Software component#Software component|components]], and increases in size, it becomes more complex. Thus, when making a more redundant system, the system also becomes more complex and developers must consider balancing redundancy with complexity.

Currently, computer science practices do not focus on building robust systems.<ref name="MIT" /> Rather, they tend to focus on [[scalability]] and [[Algorithmic efficiency|efficiency]]. One of the main reasons why there is no focus on robustness today is because it is hard to do in a general way.<ref name="MIT" />

Line 32:

===Robust network design===

Robust network design is the study of network design in the face of variable or uncertain demands.<ref>{{cite web|url=http://www-math.mit.edu/~olver/thesis.pdf |format=PDF |title=Robust Network Design |website=Math.mit.edu |accessdate=2016-11-13}}</ref> In a sense, robustness in network design is broad just like robustness in software design because of the vast possibilities of changes or inputs.

=== Robust algorithms ===

There exists algorithms that tolerate errors in the input<ref>{{cite journalbook |last1=Carbin |first1=Michael |title=Proceedings of the 19th international symposium on Software testing and analysis - ISSTA '10 |last2=Rinard |first2=Martin C. |titlechapter=Automatically identifying critical input regions and code in applications |date=12 July 2010 |pages=37–48 |doi=10.1145/1831708.1831713 |publisher=ACM|chapter-url=http://people.csail.mit.edu/rinard/paper/issta10.pdf |isbn=9781605588230 }}</ref> or during the computation.<ref name="Danglot">{{cite journal |last1=Danglot |first1=Benjamin |last2=Preux |first2=Philippe |last3=Baudry |first3=Benoit |last4=Monperrus |first4=Martin |title=Correctness attraction: a study of stability of software behavior under runtime perturbation |journal=Empirical Software Engineering |date=21 December 2017 |volume=23 |issue=4 |pages=2086–2119 |doi=10.1007/s10664-017-9571-8 |url=https://hal.archives-ouvertes.fr/hal-01378523/document|arxiv=1611.09187 }}</ref> In that case, the computation eventually converges to the correct output. This phenomenon has been called "correctness attraction".<ref name="Danglot"/>

==See also==