Software Engineering and Fault Tolerance Research Group

A Meta-Level Software Architecture based on Patterns for Developing Dependable Collaboration-based Designs

Software architectures define the overall structure and organization for designing software systems. Usually the software architecture is decided during the first design stage in which the basic approach to solving a specific problem is selected. The software architecture provides the context in which more detailed design decisions are made in later design stages and a software system's quality requirements (or attributes) are largely permitted or restrained by its architecture. The conception of dependable software architecture can become extremely difficult as different software quality requirements amalgamate with the functional requirements of the application (related with what needs to be done, independent of how it is done). In order to ease the task of constructing dependable software systems, is crucial to apply the engineering principle of separation of concerns. However, a scheme to support separation of concerns should provide: (i) separation according the multiple kinds of concerns simultaneously and (ii) overlapping/interacting concerns (not simply independent or orthogonal ones) and understanding of their mutual interference. A key goal of this work is to develop a software architecture within which multiple quality requirements related to dependability can be expressed coherently and necessary tradeoffs be made.

In this context, we focus on the design and implementation of dependable quality requirements, and their incorporation in the description of a software architecture in an explicit and structured manner. In our proposed software architecture, we are primarily concerned with the provision of features that would facilitate the design of collaborations that are expected to cope with faults. For instance, in complex concurrent dependable applications it is interesting to incorporate explicitly in the description of their software architecture the notion of coordination to support error handling and coordinated recovery between multiple interacting components.

More specifically, we propose three architectural styles for developing dependable collaboration-based software designs based on three notions: (i) the idealized fault-tolerant component model, (ii) the collaboration/role interaction model, and (iii) computational reflection together with a set of design patterns that focus on providing design solutions for implementing fault tolerance techniques, namely, error handling, coordinated recovery and software redundancy. Computational reflection defines a meta-level architecture that is composed of a base level where the application's logic is implemented and a meta level where meta components are responsible for implementing the application's quality requirements in a way that it is transparent to application designers. Application designers can apply the notion of separation of concerns and concentrate their attention on the functional requirements, abstracting from the quality requirements.

Project Members

Delano M. Beder

Up to Ongoing Projects List

Last updated October, 24 2000