Words for resulting task states in computing [closed]

Solution 1:

I will go ahead and answer this because not only do I love words, but I'm also a 25 year long professional, nearly 32 years total, in the computer science field. My specialty in fact is in .Net :)

Completed or Successful: for the task is done, finished, accomplished it's work.

Cancelled: for intentional action by the user to stop the task or process.

Aborted: for some inner state or invalid condition which causes the task to halt or stop.

Failed: for some inner state or invalid condition which causes the task to "fail" (this is similar to "abort" but the semantic difference is that aborted indicates certain things might have succeeded and the process stopped, this example could mean a larger, more critical, type of "failure" which caused the entire operation to not succeed). Failed and Aborted will not always have meaning separately depending on the context of the processes involved.

Faulted: for when the task technically completes, meaning the process was able to finish, but it had errors.

As Yosef mentioned you also might want an option for when the system is "on hold" or waiting. Waiting or Suspended are both good options for that condition. I would not use "Held".

I think your confusion about "Faulted" and "RanToCompletion" is that you are thinking Faulted means successful in exactly the same way "Completed/Completion" does? Per the documentation at your link? What it means is that the process technically finished but there were errors. This is different than cancelled in that "cancel" is a process caused by user action. "Aborted" is a process caused by an internal failure which is unrelated to user action but caused the process to be unable to complete.

"Faulted" is a special condition where a process is capable of completing (not all processes will be able to do this - depends on the context of your API and what it's doing), and it did complete, but it completed with some errors. Again, it's still a "type" of failure; one that technically completed but had errors. Not all programming processes will be capable of this condition. For example "Save File". The file either saves or it doesn't. There are no intermediate steps or conditions or processes which would allow us to say the "Save" process completed but had some errors.

Edit: I want to edit my example regarding the "Save" process, per the comments section. I'll use a simpler example, because "Save" could actually have an internal failure but still complete (see comments). It's still a "Faulted" state but, again, not all processes will be capable of a "Faulted" state.

Processes which will be able to fault will typically be processes which have multiple things going on, are capable of completing "some" things, but not others, etc...

Let's not be overly pedantic about this please. I'm trying to display the difference in meaning to a non-native speaker. Yes, you could probably always find a way to say that there is an internal failure but the process technically "completed" in which case we would call it a "Fault". That's why I used "Save" originally. But I agree it's not the best example.

A better example: "Process.OpenFile". There are not many cases where we could imagine a "fault" like behavior. Yes, yes, you could come up with scenarios. But basically if the intended action is to open a file for use (ostensibly in a GUI) for a user, then it either open's (success) or it fails (doesn't open) for use by the user.