Fernanda M. R. Alencar

Towards a unified metamodel for i

i* is a framework for goal-oriented requirements modeling. This framework contains an organizational modeling language defined by actors and dependencies among them. Although i* has been widely used, it is still hard to work with it due to its diversity of variants. In this paper, we propose a unified metamodel that presents elements of two well-known variants of i*. We show how OCL restrictions can be applied this metamodel in order to generate a specific variant. In doing so, we intend to unify the efforts of i* community. This metamodel can be useful when developing generic tools for i*, as well as to reason about i* language. Moreover, it makes it easier to extend the i* language. Thus, our proposal is an attempt towards the unification on i* variants by considering similarities and differences among them.

Deriving software architectural models from requirements models for adaptive systems: the STREAM-A approach

Some quality attributes are known to have an impact on the overall architecture of a system, so that they are required to be properly handled from the early beginning of the software development. For example, adaptability is a key concern for autonomic and adaptive systems, which brings to them the capability to alter their behavior in response to changes on their surrounding environments. In this paper, we propose a Strategy for Transition between Requirements and Architectural Models for Adaptive systems (STREAM-A). In particular, we use goal models based on the i* (i-Star) framework to support the design and evolution of systems that require adaptability. To obtain software architectures for such systems, the STREAM-A approach uses model transformations from i* models to architectural models expressed in Acme. Both the requirements and the architectural model are refined to accomplish the adaptability requirement.

Integrating organizational requirements and object oriented modeling

In recent years we have observed a growing influence of the object-oriented paradigm. Unfortunately, the current dominant object oriented modeling technique, i.e. the Unified Modeling Language, UML, is ill equipped for modeling early requirements which are typically informal and often focus on stakeholder objectives. Instead, UML is suitable for later phases of requirement capture which usually focus on completeness, consistency, and automated verification of functional requirements for the new system. We present a set of guidelines for the integration of early and late requirements specifications. For early (organizational) modeling we rely on the i* framework, whereas for late (functional) requirements specification, we rely on a precise subset of UML. A small example is used to illustrate how the requirements process iterates between early and late requirements.

Towards modular i* models

The i* framework cannot effectively model crosscutting concerns, compromising modularity, reusability and evolution of the results. Our approach embodies a specific notation to represent and compose aspectual i* models, using aspect-orientation to address modularity and composition of crosscutting concerns. This represents a step forward to improve separation of concerns in i*.

Changing attitudes towards the generation of architectural models

Architectural design is an important activity, but the understanding of how it is related to requirements modeling is rather limited. It is worth noting that goal orientation is an increasingly recognized paradigm for eliciting, modeling, specifying, and analyzing software requirements. However, it is not clear how goal models are related to architectural models. In this paper we present an approach based on model transformations to derive architectural structural specifications from system goals. The source and target languages are respectively the i* (iStar) modeling language and the Acme architectural description language. A real case study is used to show the feasibility of our approach.

From i* Requirements Models to Conceptual Models of a Model Driven Development Process

A good understanding of the systems requirements has a high impact in the successful development of software products. Therefore, an appropriate requirements model must provide a comprehensive structure for what must be elicited, evaluated, specified, consolidated, and modified, instead of just providing facilities for software specifications. Since there is a well-known gap between requirements specifications and final software products, we propose the integration of Goal-Oriented Requirements Engineering (GORE) and Model-Driven Development (MDD) to solve this gap. The core of our proposal is comprised by a set of guidelines to automate the process of going from an initial i* model to a final software product by means of a precise model transformation process. Finally, we use a case study that is based on a photographic agency system in order to illustrate our approach.

Integration of aspects with i* models

The i* framework has been widely adopted for agent-oriented modeling, as it offers a notation that provides a description in terms of dependency relationships among agents. However, the resulting models may be large and complex, with scattered concerns within the same, or among several models. These crosscutting concerns are not handled explicitly in i* models, affecting several other elements in the same model. In this paper we investigate if the Early Aspects, as promoted by the Aspect-Oriented Software Development community, can help to deal with the complexity which may arise when i* is used to develop large multi-agent systems. To achieve this we identify crosscutting concerns, keeping them in separate models. The consequence is a reduction in complexity and size of the original model. Composition rules are defined simultaneously, to keep a record of these modularized crosscutting elements. Thus, these rules work as transformations in model-driven engineering allowing us to recover the original, more refined model.

A Model Transformation Approach to Derive Architectural Models from Goal-Oriented Requirements Models

Requirements engineering and architectural design are key activities for successful development of software systems. Both activities are strongly intertwined and interrelated, but many steps toward generating architecture models from requirements models are driven by intuition and architectural knowledge. Thus, systematic approaches that integrate requirements engineering and architectural design activities are needed. This paper presents an approach based on model transformations to generate architectural models from requirements models. The source and target languages are respectively the i* modeling language and Acme architectural description language (ADL). A real web-based recommendation system is used as case study to illustrate our approach.

Stream: a strategy for transition between requirements models and architectural models

Requirements engineering and architectural design are strongly intertwined and interrelated software development activities. This paper presents a systematic approach to integrate requirements engineering and architectural design activities based on model transformations to generate architectural models from requirements models. The source and target languages are respectively the i* modeling language and Acme architectural description language. Non-functional requirements (NFRs) are used to select among architectural solutions and architectural patterns. An e-commerce system is used as running example to illustrate our approach.

Using Aspects to Simplify iModels

This poster outlines a set of rules to systematically identify crosscutting concerns present in i* models, and modularizing them using aspects. The result is the reduction of the complexity of those models