In computer science, robustness is the ability of a computer system to cope with errors during execution and cope with erroneous input. This encompasses many areas, including robust programming, robust machine learning, and robust network design. Formal techniques, such as fuzz testing, are essential for demonstrating robustness, as they involve testing with invalid or unexpected inputs. Alternatively, deliberate fault injection can be used to test robustness, and various commercial products perform robustness testing of software analysis.
Building robust systems that cover every possible point of failure is difficult due to the vast quantity of possible inputs and input combinations. Since exhaustive testing of all cases is impractical, developers generalize test cases. For example, when testing integer inputs, a developer might select a negative number, zero, and a positive number to represent the entire set of reals. This method is more efficient but more prone to failure. Generalizing test cases is one technique to deal with failure from invalid user input, but systems may also fail for other reasons, such as network disconnections. Regardless, complex systems should handle any errors gracefully, and some of the most robust systems are evolvable and easily adapted to new situations.
Challenges in Achieving Robustness
Programs and software are typically tools focused on specific tasks, making them less generalized and flexible than systems like the internet or biological systems, which adapt to their environments. One way biological systems achieve adaptation is through redundancy. For instance, humans generally need only one kidney, but having a second provides room for failure. This principle can be applied to software, but with challenges. Blindly adding code is not suggested, as it introduces more errors, increases complexity, and makes the system harder to understand. New code must possess equivalent functionality so that if one function breaks, another can replace it, using manual or automated software diversity. This requires additional logic to know how and when to accommodate the failure point, increasing system complexity. Developers must balance redundancy with complexity. Currently, computer science practices tend to focus on scalability and efficiency rather than building robust systems, partly because robustness is hard to achieve in a general way.
Robust Programming
Robust programming is a style that focuses on handling unexpected termination and unexpected actions gracefully, by displaying accurate and unambiguous error messages that help users debug programs. It is guided by several principles:
- Paranoia: The programmer assumes users are out to break the code and that their own code may fail or work incorrectly.
- Stupidity: The programmer assumes users will try incorrect, bogus, and malformed inputs. Consequently, the programmer returns unambiguous, intuitive error messages that do not require looking up error codes, aiming to be as accurate as possible without being misleading.
- Dangerous implements: Users should not gain access to libraries, data structures, or pointers to data structures. This information should be hidden to prevent accidental modification that could introduce bugs. When interfaces are correctly built, users use them without finding loopholes, focusing solely on their own code.
- Can't happen: Code modifications may introduce the possibility of an "impossible" case occurring. Such cases are assumed to be highly unlikely, and the developer implements handling for them accordingly.
Robust Machine Learning
Robustness in Machine learning typically refers to the stability of algorithms. For a machine learning algorithm to be considered robust, either the testing error must be consistent with the training error, or performance must remain stable after adding noise to the dataset. With the rise of Deep learning, there has been increasing interest in the robustness of neural networks, particularly due to their vulnerability to adversarial attacks. Research in this area often involves techniques like adversarial training, where models are trained on perturbed inputs to improve resilience. The field has connections to work by researchers such as Aleksander Madry, who has studied adversarial robustness, and Thomas G. Dietterich, who has explored error-correcting output codes and robust learning.
Robust Network Design
Robust network design is the study of designing networks in the face of variable or uncertain demands. Similar to software design, robustness in network design is broad because of the vast possibilities of changes or inputs. It involves creating networks that can maintain performance and connectivity under different traffic conditions or failures. This area is relevant to cloud infrastructure providers like Amazon Web Services, Microsoft Azure, and Google Cloud, which must ensure reliable service despite variable loads and potential hardware failures.
Robust Algorithms
There exist algorithms that tolerate errors in the input. These algorithms are designed to produce correct or acceptable outputs even when the input data contains noise, outliers, or other inaccuracies. This is particularly important in fields like computer vision and signal processing, where real-world data is often imperfect. Robust algorithms may use statistical methods to identify and downweight outliers, or they may be designed with redundancy in mind, similar to the principles of robust programming.
See Also
- Fault tolerance
- Defensive programming
- Non-functional requirement