Natural Language Requirements Research Articles

Automatic derivation of use case diagrams from interrelated natural language requirements

Automatic derivation of use case diagrams from interrelated natural language requirements

Natural language requirements testability measurement based on requirement smells

Natural language requirements testability measurement based on requirement smells

Requirement patterns in deductive verification of poST Programs

Process-oriented programming is one of the approaches to developing control software. A process-oriented program is defined as a sequence of processes. Each process is represented by a set of named states containing program code that define the logic of the process's behavior. Program execution is sequential execution of each of these processes in their current states at every iteration of the control cycle. Processes can interact through changing each other's states and shared variables. The paper expands a method for classifying temporal requirements for process-oriented programs in order to simplify and automate the deductive verification of such programs. The method consists of the following steps. At the first step, the requirements are formalized in a specialized language DV-TRL, a variant of typed first-order predicate logic with a set of interpreted types and predicate and functional symbols, that reflect specific concepts of control systems in a process-oriented paradigm. At the second step, the formalized requirements are divided into classes, each of which is defined by a pattern — a parametric formula of the DV-TRL language. The correctness conditions generated for process-oriented programs regarding requirements satisfying the same pattern have the same proof scheme. At the third step, appropriate proof schemes are developed. In our paper, we first give a brief introduction to the poST language, a process-oriented extension to the ST language of the IEC 61131-3 standard. Next, the DV-TRL language is defined. We also provide a collection of natural language requirements for several control systems. Then we define patterns that fully cover all the requirements of this collection. For each of these patterns we give an example of a formalized requirement from the collection and describe a scheme for proving the correctness conditions for this pattern. Statistics on the distribution of requirements from the collection across patterns reveals the most popular patterns. We also analyzed related works.

Development of a Language Model for Named-Entity-Recognition in Aerospace Requirements

We address the challenges inherent in converting natural language (NL) requirements into machine-readable formats by investigating the application of named-entity recognition (NER) within the aerospace domain. Recognizing the necessity for domain-specific language models, we developed an open-source annotated aerospace corpus and fine-tuned different versions of the BERT language model on the corpus to create aeroBERT-NER: a new model for identifying named entities (NEs) in the aerospace domain. A comparison between aeroBERT-NER and BERTBASE-NER demonstrated the superior performance of aeroBERT-NER in identifying NEs within a set of aerospace requirements. The identified NEs contribute to the development of a glossary, promoting consistent terminology usage in aerospace requirements and addressing challenges associated with the standardization of NL requirements.

Modeling and Verification of Natural Language Requirements based on States and Modes

The relationship between states (status of a system) and modes (capabilities of a system) used to describe system requirements is often poorly defined. The unclear relationship could make systems of interest out of control because of the out of boundaries of the systems caused by the newly added modes. Formally modeling and verifying requirements can clarify the relationship, making the system safer. To this end, an innovative approach to analyzing requirements is proposed. The MoSt language (a Domain Specific Language implemented on the Xtext framework) is firstly designed for requirements modeling and a model validator is realized to check requirements statically. A code generator is then provided to realize the automatic model transformation from the MoSt model to a NuSMV model, laying the foundation for the dynamic checks of requirements through symbolic model checking. Next, a NuSMV runner is designed to connect the NuSMV with the validator to automate the whole dynamic checks. The grammar, the model validator, the code generator, and the NuSMV runner are finally integrated into a publicly available Eclipse-based tool. Two case studies have been employed to illustrate the feasibility of our approach. For each case study, we injected 14 errors. The results show that the static and dynamic checks can successfully detect all the errors.

Automated Smell Detection and Recommendation in Natural Language Requirements

Automated Smell Detection and Recommendation in Natural Language Requirements

USE CASE TOOLS FOR IDENTIFICATION SOFTWARE REQUIREMENTS: STATE OF ART

The requirement analysis step of the Software Engineering Life Cycle (SELC) is the most crucial in order to ensure excellent quality. Besides, requirements specifications must be compared to the consistency, completeness, and correctness (3C's). Thus, dealing with Natural Language (NL) requirements makes this more challenging than usual., The problems that appear at this stage, if they are not detected or proceed, will lead to errors in the system and sometimes to the failure of the entire system; in addition to the effort required and the cost of maintenance will be large. Accordingly,to overcome these problems, differenttools have been developed and implemented to analyse the requirements through Natural Language Processing (NLP). These tools facilitate the process of eliciting requirements through Unified Modelling Language (UML) diagrams. Additionally, creating UML diagrams from NL specifications is a very difficult process. In particular, few efforts have been made in the work of extracting NL specifications, so these diagrams facilitate understanding and analysis of requirements and reduce the time of completion very significantly compared to the manual method. Using automated software engineering tools presents high-quality software that can be produced to help software developers and engineers. The main aim of this research is to concentrate onanalysing requirements based on the Use Case Diagram, which is a more popular one in UML diagram. Thus, this research will support other researchers in understanding and specifying the useful tools and mechanisms that can help them to analyse the requirements through Natural Language Processing (NLP) based UML diagrams

Natural language requirements boilerplates: an integrative literature review

In the field of Requirements Engineering, natural language is the most widely used form of documenting systems requirements, mainly for its expressiveness power, freedom of words, and easiness of use. On the other hand, written requirements are frequently ambiguous, incomplete, and incorrect, among other defects, impacting into the system lifecycle. To mitigate this issue, researchers have, since 1998, developed dozens of sets of boilerplates, aiding to guide natural language requirements composition. In this integrative literature review, authors searched for these sets in traditional academic databases, grey literature, and professional media, leading to a list of 54 relevant documents. Analysis of these primary works revealed that, even when boilerplate creators wish their artifacts to be used on all kinds of systems, they are generally cataloged under the Computer Science umbrella. It turned out to be evident that ambiguity is the main issue of quality of requirements addressed by boilerplates, followed by completeness and consistency. Authors mapped the requirements boilerplates definition modes, concluding that plain sentences are the foremost choice to describe these creations. It is claimed that systematization on the construction and evaluation of requirements boilerplates is still a problem to render these activities repeatable and reproducible, as the largest part of documents does not report it. Finally, the reported evaluation methods were hierarchically clustered, leading to three typical approaches for this activity.

Agile Methodology for the Standardization of Engineering Requirements Using Large Language Models

The increased complexity of modern systems is calling for an integrated and comprehensive approach to system design and development and, in particular, a shift toward Model-Based Systems Engineering (MBSE) approaches for system design. The requirements that serve as the foundation for these intricate systems are still primarily expressed in Natural Language (NL), which can contain ambiguities and inconsistencies and suffer from a lack of structure that hinders their direct translation into models. The colossal developments in the field of Natural Language Processing (NLP), in general, and Large Language Models (LLMs), in particular, can serve as an enabler for the conversion of NL requirements into machine-readable requirements. Doing so is expected to facilitate their standardization and use in a model-based environment. This paper discusses a two-fold strategy for converting NL requirements into machine-readable requirements using language models. The first approach involves creating a requirements table by extracting information from free-form NL requirements. The second approach consists of an agile methodology that facilitates the identification of boilerplate templates for different types of requirements based on observed linguistic patterns. For this study, three different LLMs are utilized. Two of these models are fine-tuned versions of Bidirectional Encoder Representations from Transformers (BERTs), specifically, aeroBERT-NER and aeroBERT-Classifier, which are trained on annotated aerospace corpora. Another LLM, called flair/chunk-english, is utilized to identify sentence chunks present in NL requirements. All three language models are utilized together to achieve the standardization of requirements. The effectiveness of the methodologies is demonstrated through the semi-automated creation of boilerplates for requirements from Parts 23 and 25 of Title 14 Code of Federal Regulations (CFRs).

Extraction of use case diagram elements using natural language processing and network science.

Software engineering artifact extraction from natural language requirements without human intervention is a challenging task. Out of these artifacts, the use case plays a prominent role in software design and development. In the literature, most of the approaches are either semi-automated or necessitate formalism or make use of restricted natural language for the extraction of use cases from textual requirements. In this paper, we resolve the challenge of automated artifact extraction from natural language requirements. We propose an automated approach to generate use cases, actors, and their relationships from natural language requirements. Our proposed approach involves no human intervention or formalism. To automate the proposed approach, we have used Natural Language Processing and Network Science. Our proposed approach provides promising results for the extraction of use case elements from natural language requirements. We validate the proposed approach using several literature-based case studies. The proposed approach significantly improves the results in comparison to an existing approach. On average, the proposed approach achieves around 71.5% accuracy (F-Measure), whereas the baseline method achieves around 16% accuracy (F-Measure) on average. The evaluation of the proposed approach on the literature-based case studies shows its significance for the extraction of use case elements from natural language requirements. The approach reduces human effort in software design and development.

EFFICIENT FORMALISATION OF TECHNICAL REQUIREMENTS FOR GENERATIVE ENGINEERING

AbstractCurrently, engineers need to manually analyse requirement specifications for determining parameters to create geometries in generative engineering. This analysis is time-consuming, error-prone and causes high costs. Generative engineering tools (e.g. Synera) cannot interpret natural language requirements directly. The requirements need to be formalised in a machine-readable format. AI algorithms have the potential to automatically transform natural language requirements into such a formal, machine-readable representation. In this work, a method for formalising requirements for generative engineering is developed and implemented as a prototype in Python. The method is validated in a case example using three products of an automotive engineering service provider. Requirements to be formalised are identified in the specifications of these three products, which are used as a test set to evaluate the performance of the method. The results show that requirements for generative engineering are formalised with high performance (F1 of 86.55 %). By applying the method, efforts and therefore costs for manually analysing requirements regarding parameters for generative engineering are reduced.

On the Viability of Diagrams and Drawings as System Requirements

Requirement expression media is an overlooked consideration in requirements innovation. The path to including media other than natural language requirement sentences begins with determining the viability of media to be used as requirement expressions in systems engineering. This research uses the INCOSE characteristics for individual requirements and sets of requirements as a basis for an assessment of the sufficiency of model diagrams and engineering drawings to express requirements. A critical review of high-impact sources is used to develop characteristic lists for natural language requirement sentences and for model diagrams and engineering drawings. A comparative analysis of the characteristic lists for requirement sentences, model diagrams, and engineering drawings shows that each have the same fundamental characteristics and the differences are based on the ability of the media to represent abstraction. The contribution of this research is the establishment of model diagrams and engineering drawings as viable alternatives to natural language sentences for system engineering requirements expressions.

AeroBERT-Classifier: Classification of Aerospace Requirements Using BERT

The system complexity that characterizes current systems warrants an integrated and comprehensive approach to system design and development. This need has brought about a paradigm shift towards Model-Based Systems Engineering (MBSE) approaches to system design and a departure from traditional document-centric methods. While MBSE shows great promise, the ambiguities and inconsistencies present in Natural Language (NL) requirements hinder their conversion to models directly. The field of Natural Language Processing (NLP) has demonstrated great potential in facilitating the conversion of NL requirements into a semi-machine-readable format that enables their standardization and use in a model-based environment. A first step towards standardizing requirements consists of classifying them according to the type (design, functional, performance, etc.) they represent. To that end, a language model capable of classifying requirements needs to be fine-tuned on labeled aerospace requirements. This paper presents an open-source, annotated aerospace requirements corpus (the first of its kind) developed for the purpose of this effort that includes three types of requirements, namely design, functional, and performance requirements. This paper further describes the use of the aforementioned corpus to fine-tune BERT to obtain the aeroBERT-Classifier: a new language model for classifying aerospace requirements into design, functional, or performance requirements. Finally, this paper provides a comparison between aeroBERT-Classifier and other text classification models such as GPT-2, Bidirectional Long Short-Term Memory (Bi-LSTM), and bart-large-mnli. In particular, it shows the superior performance of aeroBERT-Classifier on classifying aerospace requirements over existing models, and this is despite the fact that the model was fine-tuned using a small labeled dataset.

A property specification pattern catalog for real-time system verification with UPPAAL

Context: The goal of specification pattern catalogs for real-time requirements is to mask the complexity of specifying such requirements in a timed temporal logic for verification. For this purpose, they provide frontends to express and translate pattern-based natural language requirements to formulae in a suitable logic. However, the widely used real-time model checking tool UPPAAL only supports a restricted subset of those formulae that focus only on basic and non-nested reachability, safety, and liveness properties. This restriction renders many specification patterns inapplicable. As a workaround, timed observer automata need to be constructed manually to express sophisticated requirements envisioned by these patterns. Objective: In this work, we fill these gaps by providing a comprehensive specification pattern catalog for UPPAAL. The catalog supports qualitative and real-time requirements and covers all corresponding patterns of existing catalogs. Method: The catalog we propose is integrated with UPPAAL. It supports the specification of qualitative and real-time requirements using patterns and provides an automated generator that translates these requirements to observer automata and TCTL formulae. The resulting artifacts are used for verifying systems in UPPAAL. Thus, our catalog enables an automated end-to-end verification process for UPPAAL based on property specification patterns and observer automata. Results: We evaluate our catalog on three UPPAAL system models reported in the literature and mostly applied in an industrial setting. As a result, not only the reproducibility of the related UPPAAL models was possible, but also the validation of an automated, seamless, and accurate pattern- and observer-based verification process. Conclusion: The proposed property specification pattern catalog for UPPAAL enables practitioners to specify qualitative and real-time requirements...

ReqGen: Keywords-Driven Software Requirements Generation

Software requirements specification is undoubtedly critical for the whole software life-cycle. Currently, writing software requirements specifications primarily depends on human work. Although massive studies have been proposed to speed up the process via proposing advanced elicitation and analysis techniques, it is still a time-consuming and error-prone task, which needs to take domain knowledge and business information into consideration. In this paper, we propose an approach, named ReqGen, which can provide further assistance by automatically generating natural language requirements specifications based on certain given keywords. Specifically, ReqGen consists of three critical steps. First, keywords-oriented knowledge is selected from the domain ontology and is injected into the basic Unified pre-trained Language Model (UniLM) for domain fine-tuning. Second, a copy mechanism is integrated to ensure the occurrence of keywords in the generated statements. Finally, a requirements-syntax-constrained decoding is designed to close the semantic and syntax distance between the candidate and reference specifications. Experiments on two public datasets from different groups and domains show that ReqGen outperforms six popular natural language generation approaches with respect to the hard constraint of keywords’ (phrases’) inclusion, BLEU, ROUGE, and syntax compliance. We believe that ReqGen can promote the efficiency and intelligence of specifying software requirements.

A semi-automated approach for requirement-based early validation of flight control platforms

With the current trends in aviation like Single-Pilot-Cockpits and more autonomous functions in aircraft, flight control avionics are bound to become more complex. Future platforms will need to compensate for one or even both pilots, which will require systems that are more reliable. However, state-of-the-art development of flight control avionics does not yet support these demands efficiently. The development process involves numerous stakeholders who are communicating without streamlined interfaces. This leads to a slow and error-prone process during development. New methods are required to improve efficiency and to pave the way for future technologies. In this work, the authors introduce a semi-automatic toolchain which derives usable code for the configuration of devices from natural language requirements. The requirements are noted through modular components, stored as a model-based configuration file and are transformed into executables in the last step. This novel approach allows engineers to input their expertise when defining requirements, while removing tedious transformation tasks. Through automatic configuration testing, the validity of the approach is confirmed.

MarianCG: a code generation transformer model inspired by machine translation

The idea that computers can build their own programs is extremely significant, and many researchers are working on this challenge. Code generation is described as the process of generating executable code that can be run directly on the computer and fulfills the natural language requirements. It is an intriguing topic that might assist developers to learn a new software technology or programming language, or it could be a simple technique to help in coding through the description of the natural language code developer. In this paper, we present MarianCG, a code generation Transformer model used to tackle the code generation challenge of generating python code from natural language descriptions. Marian neural machine translation (NMT), which is the core model of the Microsoft Translator, is the basis for our NL-to-Code translation engine and is the heart of the teaching model. MarianMT is the teacher language model in our study, and it is one of the most successful machine translation transformers. In our approach, we use a sinusoidal positional embedding technique to represent the position of each token in the text, as well as no layer normalization embedding. Our code generation approach, MarianCG, is based on fine-tuning a machine translation pre-trained language model. This allows us to demonstrate that the pre-trained translation model can also operate and work as a code generation model. The proposed model outperforms recent state-of-the-art models in the problem of code generation when trained on the CoNaLa and DJANGO datasets. MarianCG model scores a BLEU score of 34.43 and an exact match accuracy of 10.2% on the CoNaLa dataset. Also, this model records a BLEU score of 90.41 and an exact match accuracy of 81.83% on the DJANGO dataset. The implementation of MarianCG model and relevant resources are available at https://www.github.com/AhmedSSoliman/MarianCG-NL-to-Code.

VIBE: Looking for Variability In amBiguous rEquirements

Variability is a characteristic of a software project and describes the fact that a system can be configured in different ways, obtaining different products (variants) from a common code base, accordingly to the software product line paradigm. This paradigm can be conveniently applied in all phases of the software process, starting from the definition and analysis of the requirements. We observe that often requirements contain ambiguities which can reveal an unintentional and implicit source of variability, that has to be detected.To this end we define VIBE, a tool supported process to identify variability aspects in requirements documents. VIBE is defined on the basis of a study of the different sources of ambiguity in natural language requirements documents that are useful to recognize potential variability, and is characterized by the use of a NLP tool customized to detect variability indicators. The tool to be used in VIBE is selected from a number of ambiguity detection tools, after a comparison of their customization features. The validation of VIBE is conducted using real-world requirements documents.

Reducing Requirements Ambiguity via Gamification: Comparison with Traditional Techniques.

Requirements elicitation is one of the most significant activities of requirements engineering (RE) process. Poorly specified requirements can lead to a failed project. Various elicitation techniques are used to elicit requirements from the users and other stakeholders, each having its own pros and cons. Lack of user engagement, less user involvement, textual nature of the requirements, time taking process are some of the major problems that make it difficult to perform elicitation via traditional techniques. Moreover, these problems further create other challenges such as ambiguity, inconsistency, and incompleteness in requirements. Currently, researchers have focused on reducing ambiguity in requirements with the help of different techniques such as natural language processing techniques, requirement templates, and formal methods; however, these techniques work on reducing ambiguity during specification or from specified requirements. One of the “young' and exciting way of engaging users in requirements elicitation of a system is “Gamification', which helps in user engagement into the system. We intend to discover how gamification helps in reducing ambiguity by engaging stakeholders in an interactive manner. In this review study, we have reviewed traditional techniques used to detect and reduce requirements ambiguity. On the contrary, we have also presented the significance of gamification in requirements elicitation and the popular but effective game elements used in similar systems. Furthermore, this study highlights the significance of using gamification in requirements elicitation, which is beneficial to software development team as well as the users involved in the system.

Natural language generation and deep learning for intelligent building codes

Many existing automated compliance checking (ACC) systems require the processes of extracting regulatory information from natural-language building-code requirements and transforming the extracted information into computer-processable semantic representations. These processes could, however, be jeopardized by the ambiguous nature of the natural language and the hierarchically complex structures of building-code requirements. To address this problem, this paper proposes the concept of intelligent building code for bypassing the error-prone information extraction and transformation processes. In the proposed intelligent code, the natural-language requirements in the code are connected with highly structured computer-understandable semantic information, which is represented in the form of semantic requirement hierarchies and can be readily used by computers for ACC. The paper also proposes a deep learning-based method to automatically generate such intelligent code. The method leverages the requirement hierarchy representation, a proposed deep learning unit-to-text model for generating requirement sentence segments, and a proposed semantic correspondence score for configuring the segments into requirement sentences. The method was implemented and tested on a dataset from multiple regulatory documents. The generated intelligent requirements were evaluated in terms of both natural-language requirement comprehensibility and correspondence between the natural language and the semantic representation, with the results indicating high performance for the proposed representation and method. The proposed intelligent code will help reduce ACC errors, improve requirement comprehensibility, and facilitate intelligent code analytics.