Textual Requirements Specification Research Articles

Automated demarcation of requirements in textual specifications: a machine learning-based approach

A simple but important task during the analysis of a textual requirements specification is to determine which statements in the specification represent requirements. In principle, by following suitable writing and markup conventions, one can provide an immediate and unequivocal demarcation of requirements at the time a specification is being developed. However, neither the presence nor a fully accurate enforcement of such conventions is guaranteed. The result is that, in many practical situations, analysts end up resorting to after-the-fact reviews for sifting requirements from other material in a requirements specification. This is both tedious and time-consuming. We propose an automated approach for demarcating requirements in free-form requirements specifications. The approach, which is based on machine learning, can be applied to a wide variety of specifications in different domains and with different writing styles. We train and evaluate our approach over an independently labeled dataset comprised of 33 industrial requirements specifications. Over this dataset, our approach yields an average precision of 81.2% and an average recall of 95.7%. Compared to simple baselines that demarcate requirements based on the presence of modal verbs and identifiers, our approach leads to an average gain of 16.4% in precision and 25.5% in recall. We collect and analyze expert feedback on the demarcations produced by our approach for industrial requirements specifications. The results indicate that experts find our approach useful and efficient in practice. We developed a prototype tool, named DemaRQ, in support of our approach. To facilitate replication, we make available to the research community this prototype tool alongside the non-proprietary portion of our training data.

TOWARDS IMPLEMENTING A FRAMEWORK FOR MODELING SOFTWARE REQUIREMENTS IN MAGICDRAW UML

UML is considered to be de facto standard for software modeling. However, in software requirements analysis it is quite common to apply only use case and activity diagrams and focus on the textual requirements specification with some non-standard graphical illustrations. In this paper we present a framework for modeling software requirements consistently using multiple UML diagrams. We illustrate the application of this framework with the examples of different requirements artifacts based on a case study system MagicTest. We discuss how such a framework could be implemented in one of the most popular UML tools, MagicDraw UML, by using its powerful features for customizing the modeling environment, defining methodology wizards, specifying validation rules, analyzing model element relationships, and generating documentation based on user-defined templates. We recognize that our approach provides the foundation, which could and should be refined and extended for special cases of requirements analysis. Our work should be considered as a starting point for practitioners trying to adopt UML for requirements analysis and for scientists working on creating more detailed requirements analysis methods based on UML.

Transforming and tracing reused requirements models to home automation models

ContextModel-Driven Software Development (MDSD) has emerged as a very promising approach to cope with the inherent complexity of modern software-based systems. Furthermore, it is well known that the Requirements Engineering (RE) stage is critical for a project’s success. Despite the importance of RE, MDSD approaches commonly leave textual requirements specifications to one side. ObjectiveOur aim is to integrate textual requirements specifications into the MDSD approach by using the MDSD techniques themselves, including metamodelling and model transformations. The proposal is based on the assumption that a reuse-based Model-Driven Requirements Engineering (MDRE) approach will improve the requirements engineering stage, the quality of the development models generated from requirements models, and will enable the traces from requirements to other development concepts (such as analysis or design) to be maintained. MethodThe approach revolves around the Requirements Engineering Metamodel, denominated as REMM, which supports the definition of the boilerplate based textual requirements specification languages needed for the definition of model transformation from application requirements models to platform-specific application models and code. ResultsThe approach has been evaluated through its application to Home Automation (HA) systems. The HA Requirement Specification Language denominated as HAREL is used to define application requirements models which will be automatically transformed and traced to the application model conforming to the HA Domain Specific Language. ConclusionsAn anonymous online survey has been conducted to evaluate the degree of acceptance by both HA application developers and MDSD practitioners. The main conclusion is that 66.7% of the HA experts polled strongly agree that the automatic transformation of the requirements models to HA models improves the quality of the HA models. Moreover, 58.3% of the HA participants strongly agree with the usefulness of the traceability matrix which links requirements to HA functional units in order to discover which devices are related to a specific requirement. We can conclude that the experts we have consulted agree with the proposal we are presenting here, since the average mark given is 4 out of 5.

Investigating the Role of Use Cases in the Construction of Class Diagrams

Several approaches have been proposed for the transition from functional requirements to object-oriented design. In a use case-driven development process, the use cases are important input for the identification of classes and their methods. There is, however, no established, empirically validated technique for the transition from use cases to class diagrams. One recommended technique is to derive classes by analyzing the use cases. It has, nevertheless, been reported that this technique leads to problems, such as the developers missing requirements and mistaking requirements for design. An alternative technique is to identify classes from a textual requirements specification and subsequently apply the use case model to validate the resulting class diagram. This paper describes two controlled experiments conducted to investigate these two approaches to applying use case models in an object-oriented design process. The first experiment was conducted with 53 students as subjects. Half of the subjects used a professional modelling tool; the other half used pen and paper. The second experiment was conducted with 22 professional software developers as subjects, all of whom used one of several modelling tools. The first experiment showed that applying use cases to validate class diagrams constructed from textual requirements led to more complete class diagrams than did the derivation of classes from a use case model. In the second experiment, however, we found no such difference between the two techniques. In both experiments, deriving class diagrams from the use cases led to a better structure of the class diagrams. The results of the experiments therefore show that the technique chosen for the transition from use cases to class diagrams affects the quality of the class diagrams, but also that the effects of the techniques depend on the categories of developer applying it and on the tool with which the technique is applied.

Systematic Model-Based Testing of Embedded Automotive Software

The software embedded in automotive control systems increasingly determines the functionality and properties of present-day motor vehicles. The development and test process of the systems and the embedded software becomes the limiting factor. While these challenges, on the development side, are met by employing model-based specification, design, and implementation techniques, satisfactory solutions on the testing side are slow in arriving. With regard to the systematic test design and the description of test scenarios especially, there is a lot of room for improvement. This paper introduces the model-based black-box testing (MB3T) approach in order to effectively minimize these de cits by creating a systematic procedure for the design of test scenarios for embedded automotive software and its integration in the model-based development process. According to the MB3T approach, logical test scenarios are rst de ned based on the textual requirements specification of the embedded software. These test scenarios are specified at a high level of abstraction and do not contain any implementation details of the test object. Due to their close link to the requirements it is easy to check which requirements are covered by which test scenario. Subsequently, the requirement-based logical tests are re ned to executable model-based test scenarios. Finally, the approach helps to check, whether or not the logical test scenarios are fully covered by the executable test scenarios. The MB3T approach has recently been successfully employed in a number of automotive embedded software development projects at DaimlerChrysler.