It is unrealistic to expect any single integration framework to emerge as THE industry standard anytime soon. Instead, multiple frameworks will continue to flourish and evolve. The community must therefore be concerned with how components or subsystems in different integration frameworks can be integrated together, how components can be designed to operate in multiple integration frameworks, and how the evolving capabilities of these frameworks can be utilized by integrated systems. These concerns are compounded by the fact that integration is primarily performed by third parties that did not develop the components being integrated.
My primary contention is that these and many other integration concerns can be addressed by exposing the full set of architectural interactions that occur between components and by enabling these interactions to be mediated.
Together, these interactions constitute the architectural behavior of the system they comprise. When we design or analyze the behavior of a system, we do so through these interactions.
Conceptually, this architectural behavior provides an ideal basis for integrating and coordinating additional components into an existing architecture. Unfortunately, currently this basis is only conceptual because the architectural behavior is neither visible nor accessible. Only the parties participating in the interaction can sense its occurrence or access the particulars of that interaction. This invisibility and inaccessibility prevents integrators from actually using that behavior as the basis of integration.
These architectural interactions can be made visible and accessible by reifying them into events and by making those events available through a publisher-subscriber mechanism. This allows "outside" programs to specify and react to the particular interactions they are interested in.
Such a mechanism is powerful enough to enable one program to monitor, track, and coordinate its behavior with the behavior of another program. Moreover, this relationship can be dynamically established and is only dependent on the architectural behavior reification infrastructure, not the explicit cooperation of the interacting components.
Many different types of Program Managers can be built. They can be constructed to authenticate users, authorize requests, enforce security or administrative policies, and enhance services (see Architecture "ilities" section).
But we will focus on their use for component integration:
The second integration manager integrates a third party analyzer into PowerPoint to determine the correctness of an architecture relative to a set of design rules and graphically annotate any errors as the architecture diagram is changed by a user. This integration manager detects user changes to a architecture diagram, extracts a topological model of the architecture, passes that model to the external analyzer, and injects any errors returned back into the architecture diagram as graphic annotations.
Both of these integration managers use the ASI and AGUI interfaces to detect critical events occurring in the applications being integrated, and their APIs to extract and insert the information being exchanged.
However, the weakness of this paradigm has been that event production was explicit. Special "Announce" or "Publish" statements were wired into the source code. This early binding of which events would be produced prevented third party integrators from specifying the particular events needed for integration. They had to be lucky enough that the required integration events were a subset of the predefined set of published events.
Program Managers eliminate this early binding problem by allowing the events to be detected to be dynamically specified and by allowing those events to be composed from any of the exposed architectural behavior of the managed component.
By changing the actual execution environment, through mediating service requests, Program Managers can substitute one resource and/or service for another and perform the translations needed for such substitutions.
Program Managers can thus create a virtual execution environment for a managed component in which the set of perceived resources and services can be changed and substitute resources and services can be transparently employed.