Armstrong Thesis Ch2: The Architectural Model

This chapter presents architecture for building fault-tolerant systems.

The keys to this software fault-tolerance are(from the paper directly):

• Software modularity through processes, and messages.
• Fault containment through fail-fast software modules.
• Process-pairs to tolerant hardware and transient software faults.
• Transaction mechanisms to provide data, and message integrity.
• Transaction mechanisms combined with process-pairs to ease exception handling, and tolerate software faults.

The main goals of programming concurrently(COPL – explained down) is reliability (through the process abstraction), scalability, security and even modularity.

Processes are stated as central items in the system and author states that the only way to have true reliability is to have each module in its own process so that errors can be contained and the process killed if an error is detected. The idea is that when the error process is killed environment can be recovered quickly as all other processes are error free and the only one which had issues have been killed. This makes the recovery easier.

Author introduced a new concept of a Concurrency Oriented Programming Language (COPL) in which programs should model the concurrent items and programmers can map the concurrency world one-to-one with the concurrency of their programs. To achieve this it is made a first class citizen of the language and the runtime environment utilizes green threads to make concurrency cheap, which gives the programmer the freedom to model all the concurrency of the problem domain. I have to read one more time to get full idea but hoping to listen to class first on this item.

Processes communicate through asynchronous message passing. So no state can be shared and process share data through message passing. This communication style supposed to enforce more reliability, since messages are asynchronous should make the system more dead lock free and programs that copy data have greater data locality and avoid false sharing, which are important for performance.