Thomas J. Graser

Enabling iterative software architecture derivation using early non-functional property evaluation

The structure of a software architecture strongly influences the architectures ability to prescribe systems satisfying functional requirements, non functional requirements, and overall qualities such as maintainability, reusability, and performance. Achieving an acceptable architecture requires an iterative derivation and evaluation process that allows refinement based on a series of tradeoffs. Researchers at the University of Texas at Austin are developing a suite of processes and supporting tools to guide architecture derivation from requirements acquisition through system design. The various types of decisions needed for concurrent derivation and evaluation demand a synthesis of evaluation techniques, because no single technique is suitable for all concerns of interest. Two tools in this suite, RARE and ARCADE, cooperate to enable iterative architecture derivation and architecture property evaluation. RARE guides derivation by employing a heuristics knowledge base, and evaluates the resulting architecture by applying static property evaluation based on structural metrics. ARCADE provides dynamic property evaluation leveraging simulation and model-checking. This paper presents a study whereby RARE and ARCADE were employed in the early stages of an industrial project to derive a Domain Reference Architecture (DRA), a high-level architecture capturing domain functionality, data, and timing. The discussion emphasizes early evaluation of performance qualities, and illustrates how ARCADE and RARE cooperate to enable iterative derivation and evaluation. These evaluations influenced DRA refinement as well as subsequent design decisions involving application implementation and computing platform selection.

Providing early feedback in the development cycle through automated application of model checking to software architectures

The benefits of evaluating properties of software architectures stem from two important software architecture roles: (1) providing an opportunity to evaluate requirements and correct defects prior to implementation; and (2) serving as a blueprint for system developers. The paper focuses on a new software architecture evaluation tool called Architecture Analysis Dynamic Environment (Arcade) that uses model checking to provide software architecture safety and liveness evaluation during the requirements gathering and analysis phase. Model checking requires expertise not typically held by systems analysts and software developers. Thus, two barriers to applying model checking must be addressed: (1) translation of the software architecture specification to a form suitable for model checking, and (2) interpretation of the results of model checking. Arcade provides an automated approach to these barriers, allowing model checking of software architectures to be added to the list of techniques available to software analysts and developers focusing on requirements gathering and analysis.

Application of the SEPA methodology and tool suite to the National Cancer Institute

In health care, as with many domains, a lack of automation has hindered its ability to accomplish its primary objectives. The paper introduces a development methodology and tool suite which provide a domain based approach to system development that addresses differing client perspectives and fosters reuse. The Systems Engineering Process Activities (SEPA) methodology emphasizes early analysis and requirements gathering activities to provide a sound foundation for object derivation. Attention paid to these early analysis activities facilitates maintaining traceability and verification of deliverables. The paper explores an example application of SEPA to the National Cancer Institutes current Protocol Authoring Tool development effort.

Evaluating dynamic correctness properties of domain reference architectures

The goals of evaluating correctness properties of software architectures include: (1) to provide an early opportunity to correct defects in requirements embodied in the software architecture, and (2) to ensure that the software architecture is an accurate blueprint for system implementers. While evaluation of both static and dynamic correctness properties is essential to achieve these goals, this paper focuses on dynamic correctness properties, including safety, liveness, and completeness. A new software architecture evaluation tool called Arcade, developed to support the Systems Engineering Process Activities (SEPA), provides dynamic correctness property evaluations using the complementary techniques of simulation and model checking. SEPA suggests a comprehensive approach to capture and represent yet separate different types of requirements as a multi-level software architecture. One SEPA architecture level, the Domain Reference Architecture (DRA), is employed early in the analysis process to represent requirements inherent to the domain, thereby specifying a reusable blueprint in terms of what processes, data, and timing are required, rather than how a system should be implemented. Arcade provides the architect with early feedback from correctness evaluations by leveraging the formal DRA meta-model to enable model checking and generating a Execution Space visualization to aid completeness validation.

Developing a traceable domain reference architecture to support clinical trials at the National Cancer Institute. An experience report

Presents the requirements gathering and software architecture derivation approach developed by the University of Texas at Austin and leveraged by the National Cancer Institute (NCI) in their efforts to automate the creation, management and evaluation of clinical trials. NCI must face the complexity of managing clinical trials and of coordinating large numbers and varied types of stakeholders. SEPA (Systems Engineering Process Activities), from the University of Texas at Austin, is well-suited to address domain modeling and software development at NCI due to a strong emphasis on explicit traceability from a derived architecture to individual knowledge acquisition sessions, as well as facilitated resolution among conflicting stakeholder contributions. Specifically, this paper focuses on the SEPA Domain Reference Architecture (DRA), a software architecture designed to capture domain requirements (i.e. domain data, functionality and timing).

The Systems Engineering Process Activities (SEPA) - supporting early requirements analysis and integration prior to implementation design

The SEPA methodology and its supporting tool suite address critical issues for software development practices: traceability between requirements, design and implementation; requirements reuse and code reuse; and systems integration. SEPA focuses on requirements analysis and integration prior to implementation design by supporting the capture of a spectrum of user inputs/requirements that are narrowed, refined and structured into a system design. User inputs require refinement for a number of reasons, including the need to (1) merge inputs from multiple sources, (2) discard irrelevant information, and (3) distinguish between general domain requirements and those relating to a specific implementation. Tools currently under development support (i) synthesizing requirements into a functional domain model, (ii) deriving object-oriented classes from the domain model, and (iii) producing a system design specification satisfying functional, performance and infrastructure requirements.

Arcade: early dynamic property evaluation of requirements using partitioned software architecture models

Abstract A fundamental goal of software engineering research is to develop evaluation techniques that enable analysis early in the software development process, when correcting errors is less costly. The Systems Engineering Process Activities (SEPA) Arcade tool employs a number of techniques to evaluate dynamic properties of requirements including correctness, performance, and reliability. To mitigate a number of practical issues associated with dynamic property evaluation, Arcade leverages the SEPA 3D Architecture, a formal requirements representation that partitions requirements types amongst a set of interrelated architecture models. This paper presents a case study illustrating how Arcade uses the SEPA 3D Architecture to help manage complexity associated with dynamic property evaluation, to reduce the level of evaluation technique expertise required to perform dynamic property evaluations, and to support an iterative, incremental approach that allows early evaluation using partial requirements models.