Composing style-based software architectures from architectural primitives

Software architectures provide high-level abstractions to deal with the complexity and richness of large-scale software systems. Often, similar architectural organization is found in different software systems. Architectural styles are an approach to exploit such similarities between different architectures. A style is useful in the design of architectures due to guarantees of desirable stylistic properties across architectures based on that style. Styles are also believed to bring economies of scale in the design and implementation of architectures. Although there are many systematic techniques for describing and selecting styles, there is considerably less underpinning for the systematic design and construction of style-based architectures. This dissertation motivates, presents, and validates a methodology for the composition of style-based software architectures from architectural primitives. This methodology, embodied as the Alfa framework, is a collection of related techniques that support the expression of stylistic constraints as well as architectural organization through the use of architectural primitives. Not only does the Alfa framework ensure the conformance of stylistic constraints in architectures using those styles, but it is also amenable to scalable implementation of architectural designs. Moreover, our methodology is comprehensive in its scope: it supports the data, structural, topological, interaction, and behavioral concerns in styles and architectures. The unique aspects of Alfa are: explicit recognition of architectural primitives that underlie a wide range of styles and architectures; type checking of data in styles and architectures, to ensure validity of architectural compositions; effective analysis of architectures for conformance to style(s) used in them, to preserve stylistic properties; and scalable implementation of architectural primitives and their composition, to support architectural prototyping. The key proposition of the dissertation is demonstrated through a case study that applies Alfa to distributed systems. The dissertation is validated analytically by deducing the algorithmic complexity of Alfa's conformance analysis; and quantitatively, by measuring the scalability of Alfa-based architectural implementations in terms of memory usage and processing time. The dissertation is concluded by inferring the consequences of Alfa on the design, analysis, and implementation of software systems.