Luiz Marcio Cysneiros

Nonfunctional requirements: from elicitation to conceptual models

Nonfunctional requirements (NFRs) have been frequently neglected or forgotten in software design. They have been presented as a second or even third class type of requirement, frequently hidden inside notes. We tackle this problem by treating NFRs as first class requirements. We present a process to elicit NFRs, analyze their interdependencies, and trace them to functional conceptual models. We focus our attention on conceptual models expressed using UML (Unified Modeling Language). Extensions to UML are proposed to allow NFRs to be expressed. We show how to integrate NFRs into the class, sequence, and collaboration diagrams. We also show how use cases and scenarios can be adapted to deal with NFRs. This work was used in three case studies and their results suggest that by using our proposal we can improve the quality of the resulting conceptual models.

A Framework for Integrating Non-Functional Requirements into Conceptual Models

The development of complex information systems calls for conceptual models that describe aspects beyond entities and activities. In particular, recent research has pointed out that conceptual models need to model goals, in order to capture the intentions which underlie complex situations within an organisational context. This paper focuses on one class of goals, namely non-functional requirements (NFR), which need to be captured and analysed from the very early phases of the software development process. The paper presents a framework for integrating NFRs into the ER and OO models. This framework has been validated by two case studies, one of which is very large. The results of the case studies suggest that goal modelling during early phases can lead to a more productive and complete modelling activity.

Integrating non-functional requirements into data modeling

Complex information systems need conceptual models to deal with aspects beyond the usual entity and activity framework. Recent research has pointed out that conceptual models need to deal with goals, in order to model complex situations that happen in the real world. Our work investigated a new strategy that allows the integration of non-functional requirements (NFR) into data models. Integration is done by representing the NFRs in a data model and investigating how NFRs satisfaction affects the data model. We adopted the widely used ER conceptual model as the data modeling representation schema. In order to start the validation of our strategy we applied it to a real system. The results so far confirm our hypothesis that NFRs integration into data models do help in achieving better understanding of what is being modeled.

NON-FUNCTIONAL REQUIREMENTS ELICITATION

Software developers are constantly under pressure to deliver code on time and on budget. As a result, many projects focus on delivering functionalities at the expense of meeting non-functional requirements such as reliability, security, maintainability, portability, accuracy, among others. As software complexity grows and clients demand higher and higher quality software, non-functional properties can no longer be considered to be of secondary importance. Many systems fail or fall into disuse precisely because of inadequacies in these properties. These nonfunctional aspects have been treated as properties or attributes after the fact. While these properties have always been a concern among software engineering researchers, early work have tended to view them as properties or attributes of the finished software product to be evaluated and measured. Recent work offer the complementary view that they should be treated as requirements to be dealt with from the earliest stages of the software development process [6][7], and then throughout the entire life cycle.

Bridging the gap between software architecture rationale formalisms and actual architecture documents: An ontology-driven approach

Documenting software architecture rationale is essential to reuse and evaluate architectures, and several modeling and documentation guidelines have been proposed in the literature. However, in practice creating and updating these documents rarely is a primary activity in most software projects, and rationale remains hidden in casual and semi-structured records, such as e-mails, meeting notes, wikis, and specialized documents. This paper describes the TREx (Toeska Rationale Extraction) approach to recover, represent and explore rationale information from text documents, combining: (1) pattern-based information extraction to recover rationale; (2) ontology-based representation of rationale and architectural concepts; and (3) facet-based interactive exploration of rationale. Initial results from TRExs application suggest that some kinds of architecture rationale can be semi-automatically extracted from a projects unstructured text documents, namely decisions, alternatives and requirements. The approach and some tools are illustrated with a case study of rationale recovery for a financial securities settlement system.

Requirements engineering in the health care domain

There are many different approaches to elicit requirements, each having strengths and weaknesses. Hence, some approaches may be more suitable to one domain than another. Moreover, some domains may require these approaches to be carefully applied or even adapted to work efficiently. Health care domain is one of these domains. It is a complex domain with many subtleties, such as political and legal issues that have to be taken into account. This work brings some of the lessons learned in more than six years working with several hospitals and laboratories. Particularly, this paper presents some elicitation techniques that had to be adapted in order to comply with the constraints imposed by several peculiarities intrinsic to this domain. It also points out some special considerations that must be taken into account regardless the method one chooses to elicit requirements.

Non-functional requirements: from elicitation to modelling languages

Although Non-Functional Requirements (NFRs) have been present in many software development methods, they have been presented as a second or even third class type of requirement, frequently hidden inside notes and therefore, frequently neglected or forgotten. Surprisingly, despite the fact that non-functional requirements arc among the most expensive and difficult to deal with there are still few works that focus on NFRs as first class requirements. Although these Works have brought a contribution on how to represent and deal with NFRs, two aspects remain not sufficiently explored: how to elicit NFRs and how to merge these NFRs with conceptual models. Our work aims at filling this gap, proposing a strategy to elicit NFRs and to integrate them into conceptual models We focus our attention on conceptual models expressed using UML, and therefore, we propose extensions to UML such that NFRs can be expressed. More precisely, we will show how to integrate NFRs to the Class, Sequence and Collaboration Diagrams. We will also show how Use Cases and Scenarios can be adapted to deal with NFRs. This work was validated by three case studies and their results suggest that by using our proposal we can improve the quality of UML models.

Requirements engineering for large-scale multi-agent systems

Large-scale software systems typically involve a large number of actors playing different roles, interacting with each other to achieve personal and common goals. As agent-based software technologies advance, systematic methods are needed to support the development of large-scale multi-agent systems. As with other kinds of software systems, successful system development relies on in-depth understanding of stakeholder needs and wants, and their effective translation into system requirements, and eventually into executable software. This paper presents a requirements engineering methodology based on agent concepts at the requirements modeling level. The strategic actor is used as the central organizing construct during requirements elicitation and analysis. In considering alternative arrangements of work processes and system interactions, strategic actors seek to exploit opportunities and avoid vulnerabilities. The methodology starts by building a lexicon as a preliminary step. The relevant actors are then identified. A breadth coverage step produces a first-cut model of the domain and the social relationships within it. The models are then developed depth-wise to capture organizational and individual goals and to explore alternatives. The methodology complements and extends the i* modelling framework. By taking into account agent characteristics such as autonomy, intentionality, and sociality starting from the requirements level, the methodology leads naturally into the development of large-scale systems that employ multi-agent software technologies. An example from the healthcare domain is used to illustrate the methodology.

Reusable knowledge for satisficing usability requirements

Usability is becoming increasingly recognized as being an important factor in the acceptance of systems by end users. There is a basic need for systematic approaches to reason, model and analyze usability from the early stages of software development. Furthermore, it is necessary to develop a usable ontology or classification of measurable aspects that can be used to aid in the specification of usability requirements. These ontologies should be represented in a way that facilitates their use as guidelines for the requirements elicitation process. This work builds on review of literature in the area of human-computer interaction and the emerging field of usability engineering in developing a catalog of aspects of usability that can be considered during requirements gathering. This catalogue is used to guide the requirements engineer through alternatives for achieving usability for information systems. The approach uses i* framework, having usability modeled as a special type of goal.

NDR Ontology: Sharing and Reusing NFR and Design Rationale Knowledge

Understanding non-functional requirements (NFR) and their solutions is a key architecture task, and reusing past solutions is an effective and efficient way to satisfy NFRs. NFR catalogues have been proposed to store and reuse NFR knowledge descriptions, yet identification of reusable knowledge inside catalogues remains quite hard and tedious. This article introduces the NDR ontology to describe NFR and design rationale knowledge, thus making it reusable and shareable via human and machine-readability. The ontology is the basis for several semantics-based applications currently under development, including view-based NFR/rationale exploration, facet-based search, and comparison of alternative solutions. Also, some approach extensions are explored, including model merging and high-end visualization of NFR knowledge.