Managing requirements on quality aspects is an important issue in the development of software systems. Difficulties arise from expressing them appropriately what in turn results from the difficulty of the concept of quality itself. Building and using quality models is an approach to handle the complexity of software quality. A novel kind of quality models uses the activities performed on and with the software as an explicit dimension. These quality models are a well-suited basis for managing quality requirements from elicitation over refinement to assurance. The paper proposes such an approach and shows its applicability in an automotive case study.
Various approaches for non-functional requirements have been proposed. The standard IEEE Std 830-1998 @cite_7 considers requirements specifications in general. It concentrates strongly on functional issues and quality requirements play only a minor role. Ebert discusses in @cite_19 an approach for managing non-functional requirements. He classifies them in and that gives them a first structure. However, this is still too coarse-grained to be applied fruitfully. Also more general approaches such as @cite_25 @cite_2 do not impose a sufficient structure on the quality requirements that foster elicitation or assurance. More structure is provided by the UMD approach @cite_15 . However, it focuses mainly on that should be avoided and hence do not provide enough connection to the stakeholders. Finally, @cite_22 included the use of quality models in their approach to non-functional requirements. However, the used quality models themselves provide no direct connection to the stakeholders.
@cite_22 @cite_7 @cite_19 @cite_2 @cite_15 @cite_25
1587460519 2144634407 2100590236 2014418954
Quality improvement such as increased reliability and maintainability are of utmost importance in software development. In this field, which was previously ad hoc and unpredictable rather than customerdoriented, increasing competition and focus on customer satisfaction have motivated management to put more emphasis on quality issues. This paper provides insight in techniques for dealing with what customers call generic quality attributes and what software engineers call nonfunctional requirements. Since requirements management more than many other disciplines in software engineering need practical insight, examples are provided for dealing with four nonfunctional requirements in large telecommunication systems, namely performance, usability, reliability, and maintainability. Guidelines are presented for specifying, constructing, analyzing, measuring and tracing nonfunctional requirements. Many examples from telecommunication system development show how to specifically and pragmatically deal with nonfunctional requirements. Extracts from three common standards (SEI CMM, ISO 9000–3, BELLCORE suite) are added in the form of a checklist for underlining the importance of proper requirements management from a customer viewpoint. 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. Non-functional characteristics of products can be essential for business success and are a key differentiator between a company and its competitors. This paper presents the application of a systematic, experience-based method to elicit, document, and analyze non-functional requirements. The objective of the method is to achieve a minimal and sufficient set of measurable and traceable non-functional requirements. The method gives clear guidance for the requirements elicitation, using workshops for capturing the important quality aspects and eliciting the non-functional requirements. This paper shows its application in three different settings, reporting the experience and lessons learned from industrial case studies that applied our NFR method. As the case studies were applied in different domains and performed with companies of various maturity, and since different quality attributes were considered, a set of interesting results has emerged. Therefore, each case study tells its own story about how the elicitation of NFR in industry can work. The paper discusses the different settings and gives a comparison of the different lessons we learned from the case studies. Developing high-quality requirements specifications often demands a thoughtful analysis and an adequate level of expertise from analysts. Although requirements modeling techniques provide mechanisms for abstraction and clarity, fostering the reuse of shared functionality (e.g., via UML relationships for use cases), they are seldom employed in practice. A particular quality problem of textual requirements, such as use cases, is that of having duplicate pieces of functionality scattered across the specifications. Duplicate functionality can sometimes improve readability for end users, but hinders development-related tasks such as effort estimation, feature prioritization, and maintenance, among others. Unfortunately, inspecting textual requirements by hand in order to deal with redundant functionality can be an arduous, time-consuming, and error-prone activity for analysts. In this context, we introduce a novel approach called ReqAligner that aids analysts to spot signs of duplication in use cases in an automated fashion. To do so, ReqAligner combines several text processing techniques, such as a use case-aware classifier and a customized algorithm for sequence alignment. Essentially, the classifier converts the use cases into an abstract representation that consists of sequences of semantic actions, and then these sequences are compared pairwise in order to identify action matches, which become possible duplications. We have applied our technique to five real-world specifications, achieving promising results and identifying many sources of duplication in the use cases.