Toward the Design and Implementation of Traceability Engineering Tool Support

Requirements of a system keep on changing based on the need of stakeholders or the system developers, making requirement engineering an important aspect in software development. This develops a need for appropriate requirement change management. The importance of requirements traceability is defining relationships between the requirements and artefacts extracted by the stakeholder during the software development life-cycle and gives vital information to encourage software understanding. In this paper, we have concentrated on developing a tool for requirement traceability that can be used to extend the requirement elicitation and identification of system-wide qualities using the notion of quality attribute scenarios to capture the non-functional requirements. It allows us to link the functional and non-functional requirements of the system based on the quality attribute scenarios template proposed by the Carnegie Mellon Software Engineering Institute (SEI). Apart from this, the paper focuses on tracing the functional and non-functional requirements of the system using the concept of requirement traceability matrix

Categorizing Non-Functional Requirements Using a Hierarchy in UML.

Non-functional requirements (NFRs) are a subset of requirements, the means by which software system developers and clients communicate about the functionality of the system to be built. This paper has three main parts: first, an overview of how non-functional requirements relate to software engineering is given, along with a survey of NFRs in the software engineering literature. Second, a collection of 161 NFRs is diagrammed using the Unified Modelling Language, forming a tool with which developers may more easily identify and write additional NFRs. Third, a lesson plan is presented, a learning module intended for an undergraduate software engineering curriculum. The results of presenting this learning module to a class in Spring, 2003 is presented

Towards a scope management of non-functional requirements in requirements engineering

Getting business stakeholders’ goals formulated clearly and project scope defined realistically increases the chance of success for any application development process. As a consequence, stakeholders at early project stages acquire as much as possible knowledge about the requirements, their risk estimates and their prioritization. Current industrial practice suggests that in most software projects this scope assessment is performed on the user’s functional requirements (FRs), while the non-functional requirements (NFRs) remain, by and large, ignored. However, the increasing software complexity and competition in the software industry has highlighted the need to consider NFRs as an integral part of software modeling and development. This paper contributes towards harmonizing the need to build the functional behavior of a system with the need to model the associated NFRs while maintaining a scope management for NFRs. The paper presents a systematic and precisely defined model towards an early integration of NFRs within the requirements engineering (RE). Early experiences with the model indicate its ability to facilitate the process of acquiring the knowledge on the priority and risk of NFRs

Approach to attributed feature modeling for requirements elicitation in Scrum agile development

Requirements elicitation is a core activity of requirements engineering for the product to be developed. The knowledge that has been gained during requirements engineering about the product to be developed forms the basis for requirement elicitation. The agile approach is becoming known day by day as the most widely used innovative process in the domain of requirements engineering. Requirements elicitation in agile development faces several challenges. Requirements must be gathered sufficiently to reflect stakeholders' needs. Furthermore, because of the development process, requirements evolve, and they must be adequately treated to keep up with the changing demands of the market and the passage of time. Another challenge with agile implementation is handling non-functional requirements in software development. Addressing non- functional requirements is still a critical factor in the success of any product. Requirements prioritization is also one of the most challenging tasks, and it is uncommon for requirement engineers to be able to specify and document all the requirements at once. This paper presents an approach for requirements elicitation in scrum-based agile development. The approach operates with the feature modeling technique, which is originally used in the Software Product Line (SPL). One of the most important proposed extensions to Feature Models (FMs) is the introduction of feature attributes. Our method uses attributed FMs to consider both functional and non-functional requirements as well as requirement prioritization. For the evaluation purposes, we have demonstrated our approach through two case studies in different domains of software product development. The first case study is in the domain of education, and the second one is in the domain of health care. The results reveal that our approach fits the requirements elicitation process in scrum agile development.Bourns College of Engineering, University of California, Riverside(undefined

Divide and Measure : CFG Segmentation for the Measurement-Based Analysis of Resource Consumption

A computer system is a good computer system if it correctly performs the task it was intended to perform. This is not even half of the truth: Non-functional requirements are abundant in the world of software and system engineering, even if they are not always stated explicitly. In our work we are concerned with the measurement-based analysis of resource consumption. Examples of resources are time, energy, or memory space. In the context of our measurement-based approach for software analysis, we face the problem of breaking the software under examination into smaller parts of managable size, a process dubbed CFG Segmentation

Performance requirements verification during software systems development

Requirements verification refers to the assurance that the implemented system reflects the specified requirements. Requirement verification is a process that continues through the life cycle of the software system. When the software crisis hit in 1960, a great deal of attention was placed on the verification of functional requirements, which were considered to be of crucial importance. Over the last decade, researchers have addressed the importance of integrating non-functional requirement in the verification process. An important non-functional requirement for software is performance. Performance requirement verification is known as Software Performance Evaluation. This thesis will look at performance evaluation of software systems. The performance evaluation of software systems is a hugely valuable task, especially in the early stages of a software project development. Many methods for integrating performance analysis into the software development process have been proposed. These methodologies work by utilising the software architectural models known in the software engineering field by transforming these into performance models, which can be analysed to gain the expected performance characteristics of the projected system. This thesis aims to bridge the knowledge gap between performance and software engineering domains by introducing semi-automated transformation methodologies. These are designed to be generic in order for them to be integrated into any software engineering development process. The goal of these methodologies is to provide performance related design guidance during the system development. This thesis introduces two model transformation methodologies. These are the improved state marking methodology and the UML-EQN methodology. It will also introduce the UML-JMT tool which was built to realise the UML-EQN methodology. With the help of automatic design models to performance model algorithms introduced in the UML-EQN methodology, a software engineer with basic knowledge of performance modelling paradigm can conduct a performance study on a software system design. This was proved in a qualitative study where the methodology and the tool deploying this methodology were tested by software engineers with varying levels of background, experience and from different sectors of the software development industry. The study results showed an acceptance for this methodology and the UML-JMT tool. As performance verification is a part of any software engineering methodology, we have to define frame works that would deploy performance requirements validation in the context of software engineering. Agile development paradigm was the result of changes in the overall environment of the IT and business worlds. These techniques are based on iterative development, where requirements, designs and developed programmes evolve continually. At present, the majority of literature discussing the role of requirements engineering in agile development processes seems to indicate that non-functional requirements verification is an unchartered territory. CPASA (Continuous Performance Assessment of Software Architecture) was designed to work in software projects where the performance can be affected by changes in the requirements and matches the main practices of agile modelling and development. The UML-JMT tool was designed to deploy the CPASA Performance evaluation tests