Scott A. Hendrickson

Modeling Product Line Architectures through Change Sets and Relationships

The essence of any modeling approach for product line architectures lies in its ability to express variability. Existing approaches do so by explicitly specifying variation points inside the architectural specification of the entire product line, usually with optional and alternative elements of some form. This, however, leads to a sizable mismatch between conceptual variability (i.e., the features through which architects logically view and interpret differences in product architectures) and actual variability (i.e., the modeling constructs through which the logical differences must be expressed). We contribute a new product line architecture modeling approach that unites the two. Our approach uses change sets to group related architectural differences and relationships to govern which change set combinations are valid when composed into a particular product architecture. The result lifts modeling of variability out of modeling architectural structure, consolidates related variation points, and explicitly and separately manages their compatibilities.

ArchStudio 4: An Architecture-Based Meta-Modeling Environment

We will demonstrate ArchStudio, an environment for software architecture modeling and meta-modeling. We will also showcase a set of innovative architecture-centric applications that use ArchStudio technologies as their basis.

ArchEvol: versioning architectural-implementation relationships

Previous research efforts into creating links between software architecture and its implementations have not explicitly addressed versioning. These earlier efforts have either ignored versioning entirely, created overly constraining couplings between architecture and implementation, or disregarded the need for versioning upon deployment. This situation calls for an explicit approach to versioning the architecture-implementation relationship capable of being used throughout design, implementation, and deployment. We present ArchEvol, a set of xADL 2.0 extensions, ArchStudio and Eclipse plug-ins, and Subversion guidelines for managing the architectural-implementation relationship throughout the entire software life cycle.

Towards supporting the architecture design process through evaluation of design alternatives

This paper addresses issues involved when an architect explore alternative designs including non-functional requirements; in our approach, non-functional requirements are expressed as state-charts. Non-functional requirements greatly impact the resulting design of a system because they naturally conflict with each other, crosscut the system at multiple points, and may be satisfied in a number of different ways. This makes correctly designing them early in the software lifecycle critical, since correcting them later can be extremely costly. Our approach supports an architect generating and evaluating many different design alternatives. This explorative process is not well supported by current techniques, which focus on documenting the result of this process, but not on assisting the designer during this process. We present an architecture-based approach that supports exploration of non-functional requirements expressed as statecharts. Our approach captures design alternatives of non-functional requirements separately, composes different system designs from these alternatives using a novel weaving technique, and analyzes the resulting design for specific qualities using simulation.

An (architecture-centric) approach for tracing, organizing, and understanding events in event-based software architectures

Applications built in a strongly decoupled, event-based interaction style have many commendable characteristics, including ease of dynamic configuration, accommodation of platform heterogeneity, and ease of distribution over a network. It is not always easy, however, to humanly grasp the dynamic behavior of such applications, since many threads are active and events are asynchronously (and profusely) transmitted. This paper presents a novel, complete approach that aids in the understanding, debugging, and visualization of the behaviors of event-based applications. It applies to real, implemented systems, without requiring the presence of component source code, and supports partial or incomplete, heuristic behavior specifications. A prototype implementation of our approach was applied to two systems, including the prototype itself, indicating that our approach is feasible, scalable, and shows promising results in terms of increasing the understandability of these types of systems.

An approach for tracing and understanding asynchronous architectures

Applications built in a strongly decoupled, event-based interaction style have many commendable characteristics, including ease of dynamic configuration, accommodation of platform heterogeneity, and ease of distribution over a network. It is not always easy to humanly grasp the dynamic behavior of such applications, since many threads are active and events are asynchronously (and profusely) transmitted. We present a set of requirements for an aid to assist in the human understanding and exploration of the behavior of such applications through the incremental refinement of rules for determining causality relationships between messages sent among components. A prototype tool is presented, indicating one viable approach to meeting these requirements. Experience with the tool reinforces some of the requirements and indicates others.

Layered class diagrams: supporting the design process

Class diagrams model a systems classes, their inter-relationships, operations, and attributes and are used for a variety of purposes including exploratory design, communication, and evaluation. However, traditional diagrams, and the tools used to create them, focus on capturing a single configuration – the product of the design process – rather than supporting the explorative design process itself that is used to create and evolve a design over time. This process involves iteration over multiple alternatives and evaluation of those alternatives. We present a layered approach and environment that encourages this process by capturing a design and its alternatives using layers. Layers may be combined with other layers to compose and explore new design alternatives for evaluation. Our tool provides mechanisms for creating, composing, and visualizing layers as well as detecting dependencies and conflicts among layers and managing semantic relationships among layers.