When we look at large real-time systems, one can usually find shortcomings of multiple sorts. Some systems do not meet the specifications, others are not flexible enough to meet the demands of changing user requirements, others cannot keep up with the growth of information; fault tolerance is not what was expected etc.
There are a number of reasons for these causes, but a good number of them are related to the fact that functions of a particular system are not “loosely coupled” enough. In other words function A influences function B in a way that was not desired. There are of course many development methods that advocate this separation but more usually fail to persevere during implementation time.
Because implementation limitations now guide the design of the system, the functional decoupling is less than ideal to say the least. One way to overcome this limitation is to use better design paradigms which are less influences by the implementation issues, another approach is to develop an architecture that is based on functional separation but at the same time support desirable features such as flexibility, redundancy, scalability etc.
Real-time systems pose additional requirements on such architecture. Actions and performance relate to the time domain of the environment (e.g. in an Air traffic control system a delay of a second has a significant impact on the validity of the data). By comparison non-real time systems have less strict implications.