Most programmers are familiar with the concept of polling. Essentially, a program repeats a loop over and over until a condition is met that triggers a reaction. The problem is that looping unnecessarily wastes CPU cycles, especially in a multithreaded system. In a reactive system, by contrast, there is no polling, which means that there is no need to use loops to test conditions. A pure reactive system is based on change. It is the ultimate event-based paradigm because nothing happens unless something changes. Rather than use polling, the process that changes a variable knows to notify each and every part of the program that might be affected by the change.
In COSA, reactivity is implemented with the use of sensors (comparison operators) and effectors. Effectors know which sensors are likely to be affected by a change to their assigned variables. The result is that event/data dependencies are automatically enforced by the system, thus leaving nothing to chance. The beauty of this is that modifications to a legacy system cannot introduce unknown side effects or bad assumptions that may lead to failures down the road.
Fine-grain parallelism is much more desirable, performance wise, than coarse-grained parallelism because it makes it possible to parallelize many things that are not parallelizable using light weight threads. For example, any initialization procedure whereby many variables in a table are assigned their initial values can be completely done in parallel in a fine-grain parallel system. These are things that multicore CPU designers need to consider. Do they really want the speed, reliability and scalability advantages of fine-grain reactive parallelism or do they just want to retain compatibility with existing development tools even though they are hard to use in a parallel environment? The choice should be obvious.