Dean and Cordy approached the problem by enriching the syntax of architecture diagrams to include a variety of distinct process and data element types. Stronger typing certainly shifts some of the inconsistency detection burden from the architecture designer to a machine. Similarly, by encoding type information into syntax, syntactic recognition methods can be fashioned to make inferences about semantics. In fact, Dean and Cordy propose to check that an architecture follows a certain architectural style through pattern matching techniques.
Inverardi and Wolf model the semantics of architecture diagrams by translating them into a program which has meaning on an abstract machine (the Chemical Abstract Machine). The Chemical Abstract Machine (or CHAM) attempts to model system behavior around the behavior of chemical reactions. The model implicitly supports an unbounded degree of parallelism and non-determinism, and it has explicit support for modularity. The CHAM language allows one to express a system as a set of molecules, heterogeneous solutions of molecules, and (rule based) reactions. The authors model architectural descriptions in this formalism by associating architectural components with molecules and expressing interaction of components through reaction rules. In so doing, an architect has a great deal of control over architectural connections and protocols at a variety of granularities. If two different architectures are defined using this method, and they contain common molecules, they may in principle be qualitatively compared with each other.
Moriconi and Qian model the semantics of architecture diagrams via constructions in a first order logic. Architectures must embody different vocabularies and concepts specific to the domain of the architecture. This makes them very difficult to compare and compose. Their idea is to represent architectures as first order logic theories. It then becomes natural to compare two theories by finding some formal system which is sufficient to model both theories. Within this model, both systems may be compared. This approach views architecture at a level which abstracts away all dependences upon machines and even architecture design languages. They give an example of showing that one architecture is a more concrete implementation of another, and conclude with some simple conditions for composing two architectures.
The syntactic approach has obvious application to architectural design language and tool development. In fact, the Dean and Cordy paper seemed slanted in the direction of motivating the approach because one could build efficient analysis systems based upon it. The paper on the whole, however, came under criticism from a number of different people. Since syntactic objects are typed, we must scrutinize the choice of types. Ultimately the author's choice of types must appeal to some semantic theory in which the types are given meaning. The authors made no attempt to do this. So, as one discussant pointed out, the authors are really dealing with semantics and sweeping it under the rug by calling it syntax.
Another observation about this paper was that it seemed vague. The choices of node types in some instances seemed somewhat arbitrary, and some of the concepts that it introduced were not made clear by examples. For instance, the authors define a heterogeneous abstraction for a connector whose realization is an edge with multiple sources and sinks. This structure does not seem intuitive, and the authors did not provide any examples which would help to make it more intuitive.
All in all, the discussion group saw the value in parsimoniously choosing a syntax for architectural design languages based upon type theory, but they thought that the authors' choice lacked clarity.
The denotational semantic approach appeals to architecture design language issues like abstraction, implementation, complexity, and composition. The paper by Moriconi and Qian took an interesting look at modeling architectures around first order theories. The approach is based upon Hoare's work in proving a data representation consistent with an interface it is supporting. Two architectures will be two theories T1 and T2. The task then is to show that T2 is a correct implementation of T1. The criteria for correctness are consistency and a weak form of completeness.
The group raised three important issues about this approach. First and most obvious, was that comparing two first order theories is tough, and it must be done for each new architectural style. The authors gave a nice exposition of the problem, but even with them skipping some of the more tedious steps the modeling problem seemed complex to everyone in the group. It was agreed upon by all that such an approach would not be feasible for practicing software architects. The authors addressed this issue by saying that this task need only be done once for each pair of styles (we assume this is done by an expert in model theory as opposed to a practicing architect). It was unclear, however, that architects could be shielded from this burden completely as there are a plethora of styles to deal with.
The second issue deals with the completeness criteria. Since an assumption of a style can not be violated by an implementation of that style, the authors require that if a is not in the abstract theory then its interpretation must no be in the concrete theory. Completeness is a difficult thing to prove between arbitrary theories.
The third issue deals with the absence of any deep composition results in the paper. The authors present an example of a syntactic condition on composition which the theory upholds, but this example is trivial. A deeper example of composition based upon this theory would have been more convincing.
The operational semantic approach provides a model which is very amenable to questions about machine-like qualities of an architecture. For example, one may very well wish to evaluate the inherent parallelism or non-determinism of an architecture. Qualities such as these are easily measured using an operational model provided that said model supports these qualities. The Chemical Abstract Machine (or CHAM) model does support these properties. Inverardi and Wolf argue that such a model is useful for describing and comparing different architectural styles with the same basic components. The model itself is very reminiscent of term rewriting systems.
The CHAM model certainly seems expressive enough to describe architectural styles. The group had one major complaint about the paper - namely proofs of termination behavior. In the example given, we did not see how the termination theorem followed when molecules could conceivable be pulled into and out of airlocks infinitely with no real progress being made.
Overall our group concluded that the proposed models are headed in the right general direction, but that models for software architecture today are far from mature, and even farther from acceptance into common use.