In many software development projects, analysts are required to deal with systems' requirements from unfamiliar domains. Familiarity with the domain is necessary in order to get full leverage from interaction with stakeholders and for extracting relevant information from the existing project documents. Accurate and timely extraction and classification of requirements knowledge support analysts in this challenging scenario. Our approach is to mine real-time interaction records and project documents for the relevant phrasal units about the requirements related topics being discussed during elicitation. We propose to use both generative and discriminating methods. To extract the relevant terms, we leverage the flexibility and power of Weighted Finite State Transducers (WFSTs) in dynamic modelling of natural language processing tasks. We used an extended version of Support Vector Machines (SVMs) with variable-sized feature vectors to efficiently and dynamically extract and classify requirements-related knowledge from the existing documents. To evaluate the performance of our approach intuitively and quantitatively, we used edit distance and precision/recall metrics. We show in three case studies that the snippets extracted by our method are intuitively relevant and reasonably accurate. Furthermore, we found that statistical and linguistic parameters such as smoothing methods, and words contiguity and order features can impact the performance of both extraction and classification tasks.

Requirements elicitation can be very challenging in projects that require deep domain knowledge about the system at hand. As analysts have the full control over the elicitation process, their lack of knowledge about the system under study inhibits them from asking related questions and reduces the accuracy of requirements provided by stakeholders. We present ELIC, a generic interactive visual analytics tool to assist analysts during requirements elicitation process. ELICA uses a novel information extraction algorithm based on a combination of Weighted Finite State Transducers (WFSTs) (generative model) and SVMs (discriminative model). ELICA presents the extracted relevant information in an interactive GUI (including zooming, panning, and pinching) that allows analysts to explore which parts of the ongoing conversation (or specification document) match with the extracted information. In this demonstration, we show that ELICA is usable and effective in practice, and is able to extract the related information in real-time. We also demonstrate how carefully designed features in ELICA facilitate the interactive and dynamic process of information extraction.

Traceability among requirements artifacts (and beyond, in certain cases all the way to actual implementation) has long been identified as a critical challenge in industrial practice. Manually establishing and maintaining such traces is a high-skill, labour-intensive job. It is often the case that the ideal person for the job also has other, highly critical tasks to take care of, so offering semi-automated support for the management of traces is an effective way of improving the efficiency of the whole development process. In this paper, we present a technique to exploit the information contained in previously defined traces, in order to facilitate the creation and ongoing maintenance of traces, as the requirements evolve. A case study on a reference dataset is employed to measure the effectiveness of the technique, compared to other proposals from the literature.

Prior studies reveal that conflicts among Non Functional Requirements (NFRs) are not always absolute. They can also be relative depending on the context of the system being developed. Given that existing techniques to manage the NFRs conflicts are mainly focused on cataloguing the interrelationships among various types of NFRs, hence a technique to manage the NFRs conflicts with respect to NFRs relative characteristic is needed. This paper presents a novel framework to manage the conflicts among NFRs with respect to NFRs relative characteristic. By applying an experimental approach, the quantitative evidence of NFRs conflicts will be obtained and modeled. NFRs metrics and measures will be used in the experiments as parameters to generate the quantitative evidence. This evidence can then allow developers to identify and reason about the NFRs conflicts. We also provide an example of how this framework could be applied.

Stakeholders frequently use speculative language when they need to convey their requirements with some degree of uncertainty. Due to the intrinsic vagueness of speculative language, speculative requirements risk being misunderstood, and related uncertainty overlooked, and may benefit from careful treatment in the requirements engineering process. In this paper, we present a linguistically-oriented approach to automatic detection of uncertainty in natural language (NL) requirements. Our approach comprises two stages. First we identify speculative sentences by applying a machine learning algorithm called Conditional Random Fields (CRFs) to identify uncertainty cues. The algorithm exploits a rich set of lexical and syntactic features extracted from requirements sentences. Second, we try to determine the scope of uncertainty. We use a rule-based approach that draws on a set of hand-crafted linguistic heuristics to determine the uncertainty scope with the help of dependency structures present in the sentence parse tree. We report on a series of experiments we conducted to evaluate the performance and usefulness of our system.

Summary form only given. Due to increasing complexity of software in embedded systems, the software development requires approaches that can manage that complexity in a similar way as this is done in general-purpose software, but at the same time provide support for embedded systems specifics. In this paper we give a short overview of a component-based approach that meets these requirements.

The identification of abstractions, i.e. terms that have a particular significance in a given domain, and such that they can indirectly characterize the most salient features of the document in which they appear, has often been recognized as a useful tool in the analysis of domain descriptions and requirements documents in software development. In this paper we propose a new technique for the identification of single- and multi-word abstractions named Relevance driven abstraction identification (RAI) and a corresponding tool implementation, present an experiment comparing the effectiveness of our technique with human judgement and with a different technique proposed in the literature, and discuss a number of ways in which the abstractions so identified can be used to good profit in requirements engineering.

We show how the Problem frames approach can be applied to identifying and structuring user interaction concerns in software requirements analysis.

This paper presents an approach to automatically identify potentially nocuous ambiguities, which occur when text is interpreted differently by different readers of requirements written in natural language. We extract a set of anaphora ambiguities from a range of requirements documents, and collect multiple human judgments on their interpretations. The judgment distribution is used to determine if an ambiguity is nocuous or innocuous. We investigate a number of antecedent preference heuristics that we use to explore aspects of anaphora which may lead a reader to favour a particular interpretation. Using machine learning techniques, we build an automated tool to predict the antecedent preference of noun phrase candidates, which in turn is used to identify nocuous ambiguity. We report on a series of experiments that we conducted to evaluate the performance of our automated system. The results show that the system achieves high recall with a consistent improvement on baseline precision subject to some ambiguity tolerance levels, allowing us to explore and highlight realistic and potentially problematic ambiguities in actual requirements documents.

We propose a structured mathematical definition of the semantics of C♯ programs to provide a platform-independent interpreter view of the language for the C♯ programmer, which can also be used for a precise analysis of the ECMA standard of the language and as a reference model for teaching. The definition takes care to reflect directly and faithfully—as much as possible without becoming inconsistent or incomplete—the descriptions in the C♯ standard to become comparable with the corresponding models for Java in Stärk et al. (Java and Java Virtual Machine—Definition, Verification, Validation, Springer, Berlin, 2001) and to provide for implementors the possibility to check their basic design decisions against an accurate high-level model. The model sheds light on some of the dark corners of C♯ and on some critical differences between the ECMA standard and the implementations of the language.

The use of logic in identifying and analyzing inconsistency in requirements from multiple stakeholders has been found to be effective in a number of studies. Nonmonotonic logic is a theoretically well-founded formalism that is especially suited for supporting the evolution of requirements. However, direct use of logic for expressing requirements and discussing them with stakeholders poses serious usability problems, since in most cases stakeholders cannot be expected to be fluent with formal logic. In this article, we explore the integration of natural language parsing techniques with default reasoning to overcome these difficulties. We also propose a method for automatically discovering inconsistencies in the requirements from multiple stakeholders, using both theorem-proving and model-checking techniques, and show how to deal with them in a formal manner. These techniques were implemented and tested in a prototype tool calledCARL. The effectiveness of the techniques and of the tool are illustrated by a classic example involving conflicting requirements from multiple stakeholders.

In this paper we present a self-stabilizing algorithm for the intruder problem. The problem can be formulated as follows: an enemy unit, or intruder, is trying to sneak through a field patrolled by an arbitrary number of friendly autonomous (i.e. robotic) units. These units must reach the intruder and block it by surrounding it. Our solution to this problem, provided as an algorithm for the autonomous patrolling units, makes minimal assumptions on their capabilities. In particular, we assume they are completely asynchronous, and moreover that they have no observable identities, no memory, and no means to explicitly communicate with each other. Each unit needs only to be capable of observing the current position of its fellows and of the intruder. All these features, while making the task harder, give to the algorithm the nice property of self-stabilization, thus improving its robustness. For example, if any unit is knocked out, all the others automatically adjust their behavior, in order to still complete the task. By concentrating on extremely simple units, we are also able to investigate which capabilities are really needed to solve this problem, with obvious cost benefits (especially if the units are deployed in a hostile environment). In the paper, we first present a computational model for our robotic "cops", followed by the description of the algorithm we propose. We also show results of computer simulations, providing quantitative measures on the efficiency of the algorithm.

Abstract In this paper, we report on our experiences of using lightweight formal methods for the partial validation of natural language requirements documents. We describe our approach to checking properties of models obtained by shallow parsing of natural language requirements, and apply it to a case study based on part of a NASA specification of the Node Control Software on the International Space Station. The experience reported supports our position that it is feasible and useful to perform automated analysis of requirements expressed in natural language. Indeed, we identified a number of errors in our case study that were also independently discovered and corrected by NASA's Independent Validation and Verification Facility in a subsequent version of the same document, and others that were not discovered. The paper describes the techniques we used, the errors we found and reflects on the lessons learned. Copyright © 2001 John Wiley & Sons, Ltd.

The use of logic in identifying and analysing inconsistency in requirements from multiple stakeholders has been found to be effective in a number of studies. Default reasoning is a theoretically well founded formalism that is especially suited for supporting the evolution of requirements. However, direct use of logic in eliciting requirements and in discussing them with stakeholders poses serious useability problems. In this paper we explore the integration of natural language parsing techniques with default reasoning to overcome these difficulties. We also propose a method for automatically discovering scenarios that expose inconsistencies in requirements, and show how to deal with them in a formal manner. These techniques were implemented and tested in a prototype tool called CARL.

The importance of requirements, which in practice often means natural language requirements, for a successful software project cannot be underestimated. Although requirement analysis has been traditionally reserved to the experience of professionals, there is no reason not to use various automatic techniques to the same end. In this paper we present Circe, a Web-based environment for aiding in natural language requirements gathering, elicitation, selection, and validation and the tools it integrates. These tools have been used in several experiments both in academic and in industrial environments. Among other features, Circe can extract abstractions from natural language texts, build various models of the system described by the requirements, check the validity of such models, and produce functional metric reports. The environment can be easily extended to enhance its natural language recognition power or to add new models and views on them.