When we try to apply our simple ideas about parallel algorithms to real parallel computers things get much more complicated.

Think about the addition example again. Suppose that the numbers are initially distributed one per processor to 8 processors. The processors are connected into a ring, and in a single time step, each processor can either perform an addition on numbers it already stores, or can pass one of its numbers on to a neighbouring processor in the ring. How many time steps do we need to add the numbers together now? Was it worth the effort?

There are many different schemes for combining processors and memories to form a parallel computer. For example, should the processors share direct access to a common set of memory modules, or should they each have their own private memory module and share information with the others by exchanging messages through some communications medium? What should the pattern of physical connectivity be? How does the time to perform some simple computation on a processor compare with the time to access some remote piece of data? The answers to these questions have serious implications for the pragmatic utility of parallel algorithms. The temptation to design algorithms for one specific parallel computer leads to programs which are not portable as new machines emerge.

The `holy grail' of parallel computing is to devise a `model of parallel computation' (in other words a statement of the ground rules for parallel algorithms) which is both flexible enough to allow the expression of good algorithms and which can also be mapped efficiently to any real parallel machine. In reality, it seems that any such model must represent a compromise between these conflicting goals.

Inheritance allows extension without replacement. Appropriate use of a feature called late binding or virtual functions increases this flexibility of components. Component based interaction allows introduction of new features by adding new objects without changing existing code.

maintenance:

Objects decouple parts of a system, i.e. objects are largely independent of each other. Fixing errors in a class definition fixes all objects derived from that class. Other parts of the system are unchanged.