3 of 5 added Robustness to title as suggested by some

How much redundancy/robustness should complex software implement?

The focus of this question: Some software performs "extra work" in order to increase the chance of a "eventually successful/satisfactory" outcome, despite one or more internal errors in the software, which requires a longer execution time when those errors happen. All these happen without the user's knowledge if the outcome was successful.

Definition of complex software:

  • Contains code written by (contributed from) more than 10 developers over its lifetime, and not written in the same time frame
  • Depends on more than 10 external libraries, each with caveats
  • A typical software task (for generating a result wanted by the user) requires 10 or more input parameters, where most of them have default values but are configurable if the user needs control.
  • Most importantly, software that has the appropriate complexity relative to the task being performed, i.e. not unnecessarily complicated.

Definition of Redundancy/Robustness within this question:
(Added Robustness based on comments)

  • If a software task failed when the current set of parameters was used, try different parameters.
    • Obviously, there must be inside knowledge that those "different" parameters use a different code path, possibly resulting in a different (hopefully better) outcome.
    • Sometimes these different code path are chosen based on observations of the external libraries.
  • At the end, if the actual task performed is slightly different from the user's specification, the user will receive a report detailing the discrepancy.
  • Finally, like the 10-plus configurable parameters, the redundancy and reporting are also configurable.

Example of such software:

  • Database Migration
    • Business database
    • Source control database, etc.
  • Batch converting between a Word document and an OpenOffice document, PowerPoint and OpenOffice Draw, etc.
  • Automatic translation of an entire website
  • Automatic analysis of software package, such as Doxygen, but where the analysis needs to be more dependable (i.e. not just a documentation tool)
  • Network communication, where packets may be lost and a number of retries are expected

This question was originally inspired from How do you deal with intentionally bad code?
but is now focused on just one of the causes of software bloat. This question does not address any other causes of software bloat, such as addition of new features.

Possibly related: How to deal with complex codes in (huge) projects