An Analysis Mechanism is a conceptual representation of a Architecture Mechanism. Over time, Analysis Mechanisms are refined into Design Mechanisms and later into Implementation Mechanisms.
Analysis Mechanisms allow the development effort to focus on understanding the requirements without getting
distracted by the specifics of a complex implementation. It is a way of abstrating away the detail of the solution to
better comprehend the problem space.
Analysis Mechanisms are described in simple terms
-
a name - to identify the Mechanism.
-
some basic attributes, to firm up the requirements around the mechanism.
Analysis Mechanisms an be identified top-down (a priori knowledge) or bottom-up (discovered as you go along).
In the top-down mode, experience guides the Architect to know that certain problems are present in the domain and will
require certain kinds of solutions. Examples of common architectural problems that might be expressed as mechanisms
during analysis are: persistence, transaction management, fault management, messaging, and inference engines. The
common aspect of all of these is that each is a general capability of a broad class of systems, and each provides
functionality that interacts with or supports the basic application functionality. The analysis mechanisms support
capabilities required in the basic functional requirements of the system, regardless of the platform it's deployed upon
or the implementation language. Analysis mechanisms also can be designed and implemented in a number of different ways;
generally there will be more than one design mechanism corresponding to each analysis mechanism, and perhaps more than
one way of implementing each design mechanism.
The bottom-up approach is where analysis mechanisms are ultimately born - they are created as the Architect sees, perhaps faintly at first, a common theme emerging from a set of
solutions to various problems. There is a need to provide a way for elements in different threads to synchronize their
clocks and there is a need for a common way of allocating resources. Analysis Mechanisms, which simplify the language of analysis, emerge from these
patterns.
Identifying an analysis mechanism means you identify that a common, perhaps implicit subproblem exists, and you
name it. Initially the name might be all that exists; for example, the system will require a persistence
mechanism. Ultimately, this mechanism will be implemented through the collaboration of various classes, some of
which do not deliver application functionality directly, but exist only to support it. Very often these support classes
are located in the middle or lower layers of a layered architecture, thereby providing a common support service to all
application level classes.
If the identified subproblem is common enough, perhaps a pattern exists from which the mechanism can be instantiated -
by binding existing classes and implementing new ones as required by the pattern. An analysis mechanism produced this
way will be abstract, and will require further refinement through design and implementation
Examples of how Architecture Mechanisms can be represented are shown in Example Analysis Mechanism Descriptions.
|