Miguel Goulão

Goal-oriented Requirements Engineering approaches have become popular in the Requirements Engineering community as they provide expressive model elements for requirements elicitation and analysis. However, as a common challenge, they are still struggling when it comes to managing the accidental complexity of their models. In this paper, we provide a set of metrics, which are formally specified and have tool support, to measure and analyze the complexity of goal models, in particular i* models. The aim is to identify refactoring opportunities to improve the modularity of those models, and consequently reduce their complexity. We evaluate these metrics by applying them to a set of well-known case studies from industry and academia. Our results allow the identification of refactoring opportunities in the evaluated models.

Background: Aspect-oriented programming (AOP) is an
emerging programming paradigm whose focus is about improving
modularity, with an emphasis on the modularization of
crosscutting concerns.

Objective: The goal of this paper is to assess the extent to which
an AOP language – ObjectTeams/Java (OT/J) – improves the
modularity of a software system. This improvement has been
claimed but, to the best of our knowledge, this paper is the first
attempting to present quantitative evidence of it.

Method: We compare functionally-equivalent implementations of
the Gang-of-Four design patterns, developed in Java and OT/J,
using software metrics.

Results: The results of our comparison support the modularity
improvement claims made in the literature. For six of the seven
metrics used, the OT/J versions of the patterns obtained
significantly better results.

Limitations: This work uses a set of metrics originally defined
for object-oriented (OO) systems. It may be the case that the
metrics are biased, in that they were created in the context of OO
programming (OOP), before the advent of AOP. We consider this
comparison a stepping stone as, ultimately, we plan to assess the
modularity improvements with paradigm independent metrics,
which will conceivably eliminate the bias. Each individual
example from the sample used in this paper is small. In future, we
plan to replicate this experiment using larger systems, where the
benefits of AOP may be more noticeable.

Conclusion: This work contributes with evidence to fill gaps in
the body of quantitative results supporting alleged benefits to
software modularity brought by AOP languages, namely OT/J.

Complex software systems inherently require a variety of models used in all of the development stages. A general concern is to guarantee consistency and traceability among these models. Model-driven development (MDD) can help tackle this concern. Although MDD has been mainly used in later development stages, it is relatively unexplored in requirements engineering. In this article, the authors discuss how to
leverage MDD to support consistency and traceability in requirements modeling. To illustrate this, they apply MDD to goaloriented requirements engineering (GORE) by making bidirectional mappings between two well-known GORE approaches (i* and KAOS). The result is an interoperable framework that can be used to migrate from one goal model to another through automatic model transformations, keeping consistency and traceability, so requirements engineers can make the best use of each approach.

A rapidly changing market leads to software systems with highly volatile requirements. In many cases, new demands in software can often be met by extending the functionality of systems already in operation. By modularizing volatile requirements that can be altered at the client’s initiative or according to market demands, we can build a stepping-stone for management of requirements change. The volatility must be managed in a way that reduces the time and costs associated with updating a system to meet the new requirements. In this chapter, we present an approach for handling volatile concerns during early life cycle software modeling. The key insight is that techniques for aspect-oriented software development can be applied to modularize volatility and to weave volatile concerns into the base software artifacts.

Helping users to find useful contacts or potentially interesting subjects is a challenge for social and productive
networks. The evidence of the content produced by users must be considered in this task, which may be simplified by the use of the meta-data associated with the content, i.e., the categorization supported by the network – descriptive keywords, or tags. In this paper we present a model that enables keyword discovery
methods through the interpretation of the network as a graph, solely relying on keywords that categorize or describe productive items. The model and keyword discovery methods presented in this paper avoid content analysis, and move towards a generic approach to the identification of relevant interests and, eventually,
contacts. The evaluation of the model and methods is executed by two experiments that perform frequency and classification analyses over the Flickr network. The results show that we can efficiently recommend keywords to users.

The i* community has published guidelines, including model layout guidelines, for the construction of models. Our goal is to evaluate the effect of the layout guidelines on the i* novice stakeholders’ ability to understand and review i* models. We conducted a quasi-experiment where participants were given two understanding and two reviewing tasks. Both tasks involved a model with a bad layout and another model following the i* layout guidelines. We evaluated the impact of layouts by combining the success level in those tasks and the required effort to accomplish them. Effort was assessed using time, perceived complexity (with NASA TLX), and eye-tracking data. Participants were more successful in understanding than in reviewing tasks. However, we found no statistically significant difference in the success, time taken, or perceived complexity, between tasks conducted with models with a bad layout and models with a good layout. Most participants had little to no prior knowledge in i*, making them more representative of stakeholders with no requirements engineering expertise. They were able to understand the models fairly well after a short tutorial, but struggled when reviewing models. Adherence to the existing i* layout guidelines did not significantly impact i* model understanding and reviewing performance.

Requirements documents and models need to be used by many stakeholders with dierent technological prociency, during software development. Each stakeholder may need to understand the entire (or simply part of the) requirements artifacts. To empower those stakeholders, views of the requirements should be congurable to their particular needs. Information visualization techniques may help in this process. In this paper, we propose dierent views aimed at highlighting information that is relevant for a particular stakeholder, helping him to query requirements artifacts. We oer three kinds of visualization capturing language and domain elements, while providing a gradual model overview: the big picture view, the syntax-based view, and the concern-based view. We instantiate these views with i* models and introduce an implementation prototype in the iStarLab tool.