Doctor of Philosophy / Department of Computing and Information Sciences / John M. Hatcliff / Software architectures—abstract interrelation models which decompose complex artifacts into modular functional units and specify the connections and relationships among them—have become an important factor in the development and maintenance of large scale, heterogeneous, information and computation systems. In system development, software architecture design has become a main starting point, and throughout the life-cycle of a system, conformance to the architecture is important to guarantee a system's integrity and consistency. For an effective use of software architectures in initial development and ongoing maintenance, the interrelation models themselves have to be clear, consistent, well structured, and—in case substantial functionality has to be added, reduced, or changed at any stage of the life cycle—flexible and manipulable. Further, enforcing the conformance of a software artifact to its architecture is a non-trivial task. Implementation units need to be identifiable and their association to the abstract constructs of the architecture has to be maintained. Finally, since software architectures can be employed at many different levels of abstraction, with some architectures describing systems that span over multiple different computing platforms, associations have to be flexible and abstractions have to be general enough to capture all parts and precise enough to be useful. An efficient and widely used way to employ software architecture in practice are middleware-based component architectures. System development within this methodology relies on the presence of a service layer called middleware which usually resides between operating system (possibly spanning over multiple operating systems on various platforms) and the application described by the architecture. The uniform set of logistic services provided by a middleware allows that communication and context requirements of the functional units, called components, can be expressed in terms of those services and therefore more shortly and concisely than without such a layer. Also, component development in the middleware context can focus on high-level functionality since the low-level logistics is provided by the middleware. While type systems have proved effective for enforcing structural constraints in programs and data structures, most architectural modeling frameworks include only weak notions of typing or rely on first-order logic constraint languages instead. Nevertheless, a consequent, adherent, use of typing can seamlessly enforce a wide range of constraints crucial for the structural integrity of architectures and the computation systems specified by them without the steep learning curve associated with first-order logic. Also, type systems scale better than first-order logic both in use and understandability/legibility as well as in computational complexity. This thesis describes component-oriented architecture modeling with CADENA and introduces the CADENA Architecture Language with Meta-modeling (CALM). CALM uses multi-level type systems to specify complex interaction models and enforce a variety of structural properties and consistency constraints relevant for the development of large-scale component-based systems. Further, CALM generalizes the notion of middleware-based architectures and uniformly captures and maintains complex interrelated architectures integrated on multiple, differing, middleware platforms. CADENA is a robust and extensible tool based on the concepts and notions of CALM that has been used to specify a number of industrial-strength component models and applied in multiple industrial research projects on model-driven development and software product lines.