COSA shares all the fault tolerance qualities of Erlang but this is where the similarities end. The COSA philosophy is that nothing should fail, period. There are software applications where safety is so critical that not even extreme reliability is good enough. In such cases, unless a program can be guaranteed 100% reliable, it must be considered defective and should not be deployed. That’s the main goal of Project COSA: 100% reliability, guaranteed.
A COSA Object or Component
Unlike Erlang and other functional languages, COSA uses a graphical approach to software construction (see figure above) because the linguistic approach is not conducive to good program comprehension in a complex parallel environment. In addition, whereas a concurrent process in Erlang can be as long (both in number of instructions and in execution time) as the programmer desires, all processes in COSA are elementary and have equal execution times. This is what is meant by COSA using synchronous processes (cells), which is not to be confused with synchronous messaging. Thus a COSA program is based on fine-grained, synchronous parallelism. The end result is that timing is rigorously deterministic. This, alone, eliminates an untold number of timing-related bugs.
Synchronous processing is an essential characteristic of COSA but there are many other equally beneficial aspects from the point of view of reliability. These are explained on the COSA website. Do take a look. There are disadvantages, of course. For example, while Erlang is available now and can run efficiently on current processors, COSA is still in the development stage and must be interpreted on current processors. The reason is that COSA is inherently non-algorithmic and current processors are designed and optimized for the algorithm. Having said that, I feel that the advantages of COSA (e.g., total reliability) far outweigh the disadvantages. Eventually, the computer industry will get tired of the heavy price its customers continue to pay for unreliable software systems. At that time, it will come to its senses and build the right CPU architecture to handle the COSA model. When that happens, all the disadvantages of COSA will disappear and we will be able to build parallel software systems of arbitrary complexity without the accompanying unreliability. It will be the golden age of automation, which is the true promise of computing. It's worth the wait, in my opinion.