Term describing a tolerable error in context of software
I am working on some software where the notion of a "less severe" error has now come up as a case to handle, and for logging purposes I want a term to use to represent these. The first to come to mind was "Soft Failure", as I am using "Failure" for the regular more-serious issues. If I do that, though, then it seems like I should rename the original to "Hard Error" by contrast. I'd really rather stick with single-word names, or at least have it be unrelated to the existing Success/Failure dichotomy.
I know this question might be a bit pedantic, but please forgive that as I'm a nut for properly naming things in a concise and descriptive way in my software (which any of you who program know is a good thing for anyone else who works with it).
Currently I'm leaning toward using "Fault", as it almost fits, but a better suggestion would be welcomed.
Edit: Since others seem to have a bit of the wrong idea of what I mean, let me clarify. The term would not be used to refer to a completely unexpected failure - that's what "Failure" is for in the system. This is for expected but rare events that aren't good but aren't a problem in the software. For example, you connect to a database and try to grab a value, but the connection times out due to latency. Another example could be that upon trying to get a value it is missing from the database entirely. Again, this isn't "broken", it's just a missing piece of data, but everything is operating properly. That makes things like "glitch" and "bug" feel ill-suited.
Most users understand the distinction between Warning and Error
So, if the issue is fairly mild and recoverable, then you term this as a Warning and let the user have some way of rectifying the situation (if applicable).
If the situation isn't rectifiable, then you have at least warned the user that something is amiss.
This seems (at least to me) to be understandable and straight-forward (which what we typically want in program messages).
In logging, there's typically three severity levels:
1) Error - Something's gone wrong and can't be recovered
2) Warning - Something's gone wrong, but it's not too bad
3) Information - Nothing's gone wrong, but the event is logged for logging's sake (x process has started/finished etc.)
There's actually a lot of more-or-less standard terminology for this in various bug-tracking systems.
Cosmetic refers to an error that does not affect functionality, but rather is visual only. Examples include a mis-spelled word, a problem in alignment of two form fields, or inconsistent colors.
Blocking refers to an error that completely prevent some portion of the functionality from working: a form can't be submitted, a report contains no data, etc.
In between those two extremes, you can have intermediate fault levels such as "major" and "minor".
Recoverable Error as a distinction from the severe errors / exceptions.
- a program error that can be corrected and does not cause the program to fail or irretrievably lose data.