Jon Whittle

Model composition in product lines and feature interaction detection using critical pair analysis

Software product lines (SPL) are an established technology for developing families of systems. In particular, they focus on modeling commonality and variability, that is, they are based on identifying features common to all members of the family and variable features that appear only in some members. Model-based development methods for product lines advocate the construction of SPL requirements, analysis and design models for features. This paper describes an approach for maintaining feature separation during modeling using a UML composition language based on graph transformations. This allows models of features to be reused more easily. The language can be used to compose the SPL models for a given set of features. Furthermore, critical pair analysis is used to detect dependencies and conflicts between features during analysis and design modeling. The approach is supported by a tool that allows automated composition of UML models of features and detection of some kinds of feature interactions.

Modeling and composing scenario-based requirements with aspects

There has been significant recent interest, within the aspect-oriented software development (AOSD) community, in representing crosscutting concerns at various stages of the software lifecycle. However, most of these efforts have concentrated on the design and implementation phases. We focus in This work on representing aspects during use case modeling. In particular, we focus on scenario-based requirements and show how to compose aspectual and non-aspectual scenarios so that they can be simulated as a whole. Non-aspectual scenarios are modeled as UML sequence diagrams. Aspectual scenarios are modeled as interaction pattern specifications (IPSs). In order to simulate them, the scenarios are transformed into a set of executable state machines using an existing state machine synthesis algorithm. Previous work composed aspectual and non-aspectual scenarios at the sequence diagram level. In This work, the composition is done at the state machine level.

Scenario modelling with aspects

There has been significant recent interest, within the aspect-oriented software development (AOSD) community, in representing crosscutting concerns at various stages of the software lifecycle. However, most of these efforts have concentrated on the design and implementation phases. The focus of this paper is on representing aspects during requirements modelling. In particular, the issue of how to model aspects as part of scenario-based modelling is addressed. The use of scenarios is common in requirements development and analysis. The authors describe how to represent and compose aspects at the scenario level. Aspectual scenarios are modelled as interaction pattern specifications (IPSs) and are composed with nonaspectual scenarios using instantiation and special composition operators. The composed collection of scenarios can then be translated automatically into a set of state machines using an existing state machine synthesis algorithm. The resulting set of state machines is an executable form of the scenarios and can be used for simulation and analysis of the requirements.

An expressive aspect composition language for UML state diagrams

The goal of aspect-oriented software development is to maintain a clear separation of concerns throughout the software lifecycle. Concerns that are separated, however, must be composed at some point. The hypothesis in this paper is that existing aspect-oriented modeling composition methods are not expressive enough for composing state-dependent behavioral models. The paper presents a new aspect composition language, SDMATA, for UML state diagrams. SDMATA supports a richer form of model composition than previous approaches to aspect-oriented modeling. Firstly, pointcuts are given as patterns which allows for sequence pointcuts, loop pointcuts, etc. Secondly, SDMATA supports rich forms of composition including parallel composition and alternative composition. The language is applied to the use case slice technique of Jacobson and Ng. The findings are that it is possible to maintain the separation of state-dependent models during software design and that expressive model composition methods are necessary to do this in practice.

From scenarios to code: an air traffic control case study

Two high profile workshops at OOPSLA and ICSE, an IEEE Computer article by David Harel and a growing number of research papers have all suggested algorithms that translate scenarios of a systems behavior into state machines. One of the uses of such algorithms is in the transition from requirements scenarios to component design. To date, however, most efforts have concentrated on the algorithmic details of the proposed translations. Less work has been done on evaluating these algorithms on a realistic case study. In this paper, we do exactly that for the algorithm presented in [10]. Our study is a component of an air traffic advisory system developed at NASA Ames Research Center.

Generating Hierarchical State Machines from Use Case Charts

There are many examples, in the literature, of algorithms for synthesizing state machines from scenario-based models. The motivation for these is to automate the transition from scenario-based requirements to early analysis and design models. A major challenge for such algorithms, however, is that the relationships between scenarios are usually not explicitly defined. This means that synthesis algorithms have to infer the relationships and this cannot generally be done without also inferring false positives. An alternative is to require users to explicitly give scenario relationships. The challenge here is that the additional burden placed on the user must be less than the effort saved by automatic synthesis. In this paper, we address this problem by defining a synthesis algorithm for use case charts, a language for precisely describing use cases and their relationships. Use case charts are sufficiently precise to allow the automatic generation of hierarchical state machines but retain the benefits of existing scenario-based notations by being based on UML. Use case charts provide an easy way of specifying scenario relationships but also have a formal semantics that can be used both in synthesis and to execute the use case charts. This paper presents the synthesis algorithm for use case charts and illustrates it on a significant example based on students solutions to an analysis and design problem

Automating the implementation of Kalman filter algorithms

autofilter is a tool that generates implementations that solve state estimation problems using Kalman filters. From a high-level, mathematics-based description of a state estimation problem, autofilter automatically generates code that computes a statistically optimal estimate using one or more of a number of well-known variants of the Kalman filter algorithm. The problem description may be given in terms of continuous or discrete, linear or nonlinear process and measurement dynamics. From this description, autofilter automates many common solution methods (e.g., linearization, discretization) and generates C or Matlab code fully automatically. autofilter surpasses toolkit-based programming approaches for Kalman filters because it requires no low-level programming skills (e.g., to glue together library function calls). autofilter raises the level of discourse to the mathematics of the problem at hand rather than the details of what algorithms, data structures, optimizations and so on are required to implement it. An overview of autofilter is given along with an example of its practical application to deep space attitude estimation.

Transformations and Software Modeling Languages: Automating Transformations in UML

This paper investigates the role of transformations in the Unified Modeling Language, specifically UML class diagrams with OCL constraints. To date, the use of transformations in software modeling and design has not been fully explored. A framework for expressing transformations is presented along with concrete examples that, for example, infer new inheritance links, or transform constraints. In particular, a technique for checking that two UML class diagrams are refactorings of each other is described.

On the usage of concrete syntax in model transformation rules

Graph transformations are one of the best known approaches for defining transformations in model-based software development. They are defined over the abstract syntax of source and target languages, described by metamodels. Since graph transformations are defined on the abstract syntax level, they can be hard to read and require an in-depth knowledge of the source and target metamodels. In this paper we investigate how graph transformations can be made much more compact and easier to read by using the concrete syntax of the source and target languages. We illustrate our approach by defining model refactorings.

From scenarios to code: An air traffic control case study

There has been much recent interest in synthesis algorithms that generate finite state machines from scenarios of intended system behavior. One of the uses of such algorithms is in the transition from requirements scenarios to design. Despite much theoretical work on the nature of these algorithms, there has been very little work on applying the algorithms to practical applications. In this paper, we apply the Whittle & Schumann synthesis algorithm [32] to a component of an air traffic advisory system under development at NASA Ames Research Center. We not only apply the algorithm to generate state machine designs from scenarios but also show how to generate code from the generated state machines using existing commercial code generation tools. The results demonstrate the possibility of generating application code directly from scenarios of system behavior.