World Library  
Flag as Inappropriate
Email this Article

Robustness (computer science)

Article Id: WHEBN0027206541
Reproduction Date:

Title: Robustness (computer science)  
Author: World Heritage Encyclopedia
Language: English
Subject: Complex systems, Cohesion (computer science), Responsiveness, Stable storage, Fault injection
Collection: Reliability Engineering
Publisher: World Heritage Encyclopedia
Publication
Date:
 

Robustness (computer science)

In computer science, robustness is the ability of a computer system to cope with errors during execution. Robustness can also be defined as the ability of an algorithm to continue operating despite abnormalities in input, calculations, etc. Robustness can encompass many areas of computer science, such as robust programming, robust machine learning, and Robust Security Network form, the more robust the software. 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 systems, and is a process of failure assessment analysis.[1]

Contents

  • Introduction 1
  • Challenges 2
  • Areas 3
    • Robust programming 3.1
      • Principles 3.1.1
    • Robust machine learning 3.2
    • Robust network design 3.3
  • Examples 4
  • See also 5
  • References 6

Introduction

In general, building robust systems that encompass every point of possible failure is difficult because of the vast amount of possible inputs and input combinations.[2] 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.[3] For example, imagine inputting in some 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.[2]

Challenges

Programs and software are tools focused on a very specific task, and thus aren't generalized and flexible.[2] However, observations in systems such as the kidney is one such example. Humans 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.[4] Code that doesn't provide any reinforcement to the already existing code is unwanted. The new code must instead possess equivalent functionality, so that if a function is broken, another providing the same function can replace it. To do so, the new code must know how and when to accommodate the failure point.[2] This means more logic needs to be added to the system. But as a system adds more logic, 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.[2] Rather, they tend to focus on scalability and 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.[2]

Areas

Robust programming

Robust programming is a style of programming that focuses on handling unexpected termination and unexpected actions.[5] It requires code to handle these terminations and actions gracefully by displaying accurate and unambiguous error messages. These error messages allow the user to more easily debug the program.

Principles

Paranoia - When building software, the programmer assumes users are out to break their code.[5] The programmer also assumes that his or her own written code may fail or work incorrectly.[5]

Stupidity - The programmer assumes users will try incorrect, bogus and malformed inputs.[5] As a consequence, the programmer returns to the user an unambiguous, intuitive error message that does not require looking up error codes. The error message should try to be as accurate as possible without being misleading to the user, so that the problem can be fixed with ease.

Dangerous implements - Users should not gain access to libraries, data structures, or pointers to data structures.[5] This information should be hidden from the user so that the user doesn't accidentally modify them and introduce a bug in the code. When such interfaces are correctly built, users use them without finding loopholes to modify the interface. The interface should already be correctly implemented, so the user does not need to make modifications. The user therefore focuses solely on his or her own code.

Can't happen - Very often, code is modified and may introduce a possibility that an "impossible" case occurs. Impossible cases are therefore assumed to be highly unlikely instead.[5] The developer thinks about how to handle the case that is highly unlikely, and implements the handling accordingly.

Robust machine learning

Robust machine learning typically refers to the robustness of machine learning algorithms. For a machine learning algorithm to be considered robust, either the testing error has to be consistent with the training error, or the performance is stable after adding some noise to the dataset.[6]

Robust network design

Robust network design is the study of network design in the face of variable or uncertain demands.[7] In a sense, robustness in network design is broad just like robustness in software design because of the vast possibilities of changes or inputs.

Examples

  • Examples Robustness Requirements

See also

References

  1. ^ http://www.stanford.edu/~bakerjw/Publications/Baker%20et%20al%20(2008)%20Robustness,%20Structural%20Safety.pdf
  2. ^ a b c d e f g http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf
  3. ^ http://www.softwaretestingclub.com/profiles/blogs/importance-of-making
  4. ^ http://www.cse.sc.edu/~huhns/journalpapers/V6N2.pdf
  5. ^ a b c d e f http://nob.cs.ucdavis.edu/bishop/secprog/robust.html
  6. ^ http://www.researchgate.net/post/What_is_the_definition_of_the_robustness_of_a_machine_learning_algorithm.
  7. ^ http://www-math.mit.edu/~olver/thesis.pdf
This article was sourced from Creative Commons Attribution-ShareAlike License; additional terms may apply. World Heritage Encyclopedia content is assembled from numerous content providers, Open Access Publishing, and in compliance with The Fair Access to Science and Technology Research Act (FASTR), Wikimedia Foundation, Inc., Public Library of Science, The Encyclopedia of Life, Open Book Publishers (OBP), PubMed, U.S. National Library of Medicine, National Center for Biotechnology Information, U.S. National Library of Medicine, National Institutes of Health (NIH), U.S. Department of Health & Human Services, and USA.gov, which sources content from all federal, state, local, tribal, and territorial government publication portals (.gov, .mil, .edu). Funding for USA.gov and content contributors is made possible from the U.S. Congress, E-Government Act of 2002.
 
Crowd sourced content that is contributed to World Heritage Encyclopedia is peer reviewed and edited by our editorial staff to ensure quality scholarly research articles.
 
By using this site, you agree to the Terms of Use and Privacy Policy. World Heritage Encyclopedia™ is a registered trademark of the World Public Library Association, a non-profit organization.
 


Copyright © World Library Foundation. All rights reserved. eBooks from Project Gutenberg are sponsored by the World Library Foundation,
a 501c(4) Member's Support Non-Profit Organization, and is NOT affiliated with any governmental agency or department.