I would like to better understand what is happening quickly and without fail.
What seems to me at first glance is that failure means that we want the system to obviously fail when some unexpected thing happens. I mean, for example, if a factory cannot create an instance of an object, for the principle of quick synchronization, we really do not want the factory to return a null or empty object or a partially initialized object, which could have a chance, will be used correctly by the application β in most cases we would have unexpected behavior, or an unexpected exception raised at a different level that would not allow us to know the real thing, is in the factory. Is that what this principle means?
The principle of shocklessness is quite difficult for me to understand. The most common example of Java is collection, their iterators, and concurrent access. He said that the assembler / iterator, which allows you to modify the list when iterates over it, is called fail-safe. This is usually done by finally repeating a copy of the original list. But in this example, I really do not understand where the system fails ... and thus, while it is fail-safe ... Where is the error? We just iterate over the copy or not, depending on our needs ... I see no match with the fault tolerance wiki definition ...
Thus, in articles such as:
http://www.certpal.com/blogs/2009/09/iterators-fail-fast-vs-fail-safe/
They are against unsuccessful fault tolerance ... what I just don't understand - this is why we call fault tolerant this iteration over the copy ...
:
http://tutorials.jenkov.com/java-exception-handling/fail-safe-exception-handling.html
, -, .
, , , , , , , , - . , . Fail-safe , , - ...
, .
?
?