Mission-critical software system (such as systems-control software in spacecrafts) often employ multiple redundant software modules developed by different teams (sometimes using different programming languages), to same interface and behavioural specifications. The idea being that software bugs that surface only during some extreme corner-cases, not caught in pre-production testing should be localized to implementation in only one of the modules, leaving other modules unimpacted since they are developed by different teams using different tools/languages.
However, there are these somewhat less (mission-)critical systems whole malfunction can have significant financial impact, do manage to be fault-tolerant, seemingly using redundant instance of software written in same language, perhaps by same team of developers, which not only ensure high-availability but also fault-tolerance for ongoing transactions, such that fault on one node serving a request can continue seamlessly on another node. In case of hardware fault, I can understand why this could work. However, in case of software fault, why/how does it work ? Isn't it that the same software fault that caused failure of first node, would impact the other node as well ?
Also, are there some design patterns that permit composing a fault tolerant system using components that are intrinsically not fault tolerant ?