Advance Program

An Ontological Framework for Architecture Model Integration
Arvind Kiwelekar and Rushikesh K. Joshi
(Dr. Babasaheb Ambedkar Technological University, India; IIT Bombay, India) Architecture Model Integration is a process of defining correspondences between high-level architecture elements and other software elements from artifacts developed during various phases of product life cycle. A primary purpose of this process of integration is to address the challenges of the semantic gap that results due to scattering of concerns into multiple representations of application domain entities throughout a series of models. An ontological approach aimed to address the semantic gap is presented in this paper. A reference architecture ontology and an architecture knowledge base are the central components of the proposed framework. Around these components, three framework processes namely interpretation, representation, and refinement are integrated. The framework processes are uniformly applied to derive architecture models from artifacts developed during requirements, low-level design, and implementation.

coffee break  

A Framework for Identifying and Analyzing Non-functional Requirements from Text
Vibhu Saujanya Sharma, Roshni R. Ramnani, and Shubhashis Sengupta
(Accenture Technology Labs, India)
Early identification of Non-Functional Requirements (NFRs) is important as this has direct bearing on the design and architecture of the system. NFRs form the basis for architects to create the technical architecture of the system which acts as the scaffolding in which the functionality of the same is delivered. Failure to identify and analyze NFRs early-on can result in unclassified, incomplete or conflicting NFRs, and this typically results in costly rework in later stages of the software development. In practice, this activity is primarily done manually. In this paper, we present a framework to automatically detect and classify non-functional requirements from textual natural language requirements. Our approach to identify NFRs is based on extracting multiple features by parsing the natural language requirement whereby the presence of a certain combination of and relationship among the features uniquely identifies the requirement as an NFR of a particular category. These features are specified as pattern based rules which can be specified in a human readable language through the use of a domain specific language that we have defined. This enables great ease and flexibility in creating and extending rules. Our approach has been implemented as a prototype tool and here we also present the results of applying our approach on a publicly available requirement corpus.

Lunch  

Engineering Support for Virtual Integration
Mike Whalen (Invited talk)
University of Minnesota, USA
Nuseibeh's TwinPeaks paper makes the argument that system design naturally iterates between activities in the "problem space" where we do goal and requirements exploration and the "solution space" where we explore means to implement aspects of the system. In previous work, we pointed out that this idea naturally describes hierarchical construction, in which design choices made at higher levels of abstraction levy requirements on system components at lower levels of abstraction. Thus, whether an aspect of the system is a design choice or a requirement depends largely on one's vantage point within the hierarchy of system components. Given a hierarchy of requirements and design information, we can perform "virtual integration"; that is, determining whether the system (at some level in the hierarchy) meets its functional, performance, and resource requirements given requirements of subcomponents. If the subcomponents are correctly implemented with respect to their requirements, this approach should allow smooth system integration. Unfortunately, it is often the case that we incompletely specify certain aspects of the system or create a set of requirements that are unrealizable, that is, it is impossible to create an implementation that simultaneously satisfies all of its requirements. In this talk, I discuss tool support towards performing virtual integration with confidence and some examples using the Architectural Analysis Design Language (AADL) and AGREE plugin for formal verification.

Exploring the Twin Peaks using Probabilistic Verification Techniques
Anitha Murugesan, Lu Feng, Mats P. E. Heimdahl, Sanjai Rayadurgam, Michael W. Whalen, and Insup Lee
(University of Minnesota, USA; University of Pennsylvania, USA) System requirements and system architecture/design co-evolve as the understanding of both the problem at hand as well as the solution to be deployed evolve---the Twin Peaks concept. Modeling of requirements and solution is a promising approach for exploring the Twin Peaks. Commonly, such models are deterministic because of the choice of modeling notation and available analysis tools. Unfortunately, most systems operate in an uncertain environment and contain physical components whose behaviors are stochastic. Although much can be learned from modeling and analysis with commonly used tools, e.g., Simulink/Stateflow and the Simulink Design Verifier, the SCADE toolset, etc., the results from the exploration of the Twin Peaks will---by necessity---be inaccurate and can be misleading; inclusion of the probabilistic behavior of the physical world provides crucial additional insight into the system's required behavior, its operational environment, and the solution proposed for its software. Here, we share our initial experiences with model-based deterministic and probabilistic verification approaches while exploring the Twin Peaks. The intent of this paper is to demonstrate how probabilistic reasoning helps illuminate weaknesses in system requirements, environmental assumptions, and the intended software solution, that could not be identified when using deterministic techniques. We illustrate our experience through a medical device subsystem, modeled and analyzed using the Simulink/Stateflow (deterministic) and PRISM (probabilistic) tools.

coffee break