2026· Journal of Communications Software and Systems· Vol 22, pp. 400-410· 1 citation· 45 references
TL;DR
An automated framework is proposed based on Natural Language Processing (NLP) techniques to parse the software requirements syntactically using a set of heuristic rules that facilitate the extraction of actors, use cases, entities, relationships, and attributes from software requirements documents written in natural language.
Abstract
— Use case and class diagramming are essential requirements engineering techniques that play a pivotal role in modeling software specifications and facilitating the software development process. However, software requirements are often expressed in Natural Language (NL), which can be ambiguous, noisy, immeasurable, and open to interpretation. This research addresses these challenges by automatically extracting the required elements to generate use case and class diagrams from software requirements documents written in natural language. Accordingly, an automated framework is proposed based on Natural Language Processing (NLP) techniques—such as tokenization and part-of-speech tagging—to parse the software requirements syntactically using a set of heuristic rules. These rules facilitate the extraction of actors, use cases, entities, relationships, and attributes required for generating the corresponding diagrams. Furthermore, to enhance the framework’s performance, the k-nearest neighbor (k-NN) algorithm is employed to predict previously processed requirements and reduce redundant computation. The framework’s effectiveness was evaluated using two performance metrics: recall and precision. Experimental results show that the proposed approach achieves an average recall of 96% and an average precision of 92%, confirming its robustness and reliability.
In agile development, user stories express stakeholder needs, and the associated acceptance criteria (AC), written in the Given/When/Then (GWT) notation, specify the behaviour expected of the system under stated preconditions. Their manual translation into UML activity diagrams is laborious and remains sensitive to wording differences between authors. Existing automated approaches rely on lexical matching or on grammatical rules. Both fail when an identical precondition is expressed through different wording, a case that occurs frequently in collaborative backlogs. This study introduces GTA (GWT-to- Activity), a deterministic pipeline that converts GWT AC into UML activity diagrams. The clause structure is first recovered through dependency parsing. Paraphrased Given states are then merged based on sentence embedding similarity using Sentence-BERT (SBERT), and natural language inference (NLI) is used to separate semantic opposition from lexical variation, with thresholds calibrated on annotated data to preserve output stability under paraphrastic variation. Eleven behavioural patterns are supported, from simple sequences to nested compound conditions. The pipeline was evaluated on 107 test sets containing 230 AC drawn from four heterogeneous corpora of synthetic, open-source, and benchmark origin, and it reaches a node F1-score of 99.26%, an edge F1-score of 97.37%, and an exact topological match rate of 95.33%. All eleven patterns are recovered, and every generated file is a valid PlantUML that requires no post-processing. The output is structurally correct, deterministic from one run to another, and traceable to the thresholds set at each gate.
Samia Nasiri, Salim Bloundi, M. Lahmer· International Journal of Adv...· 0 citations
Design documents contain essential design knowledge such as designers’ intent, decision-making criteria, and constraints, and are widely used to support accurate and consistent product development. Most design documents are extensive and composed of unstructured natural language-based text, which makes it difficult for humans to manually read and retrieve relevant information efficiently. To address this challenge, this study proposes an LLM-based design document understanding approach for structurally organizing implicit design information embedded in unstructured design documents. A sentence-level semantic classification framework is introduced to categorize design sentences according to quantitative and functional characteristics. In addition, contextual information is leveraged to identify the design object described by each sentence automatically. Design semantics classification and design object identification experiments were conducted by fine-tuning various Natural Language Processing (NLP) models and LLMs, achieving accuracy of 87.2% and 91.0%, respectively. Furthermore, a case study on automated design verification using real 3D CAD models demonstrates that the proposed approach can be directly applied to design automation tasks.
Junho Kim, Sangwook Park, Seungeun Lim et al.· Journal of Computational Des...· 0 citations
This work proposes LLM-based methods for verifying semantically complex NL requirements on static GUI prototypes and introduces a multimodal LLM-based agent for verifying complex functional and non-functional requirements in dynamic GUI applications through automatically generated and evaluated interaction trajectories.
Evaluated on real-world system-level requirements documents, comprising more than 720 requirements and 72 use cases, the approach generates system-level diagrams comparable to those created by experts and provides valuable architectural recommendations.
Bastian Franze, Dominik Fuchß, Friedrich Wattenberg et al.· IEEE International Requireme...· 0 citations
This paper presents a framework integrating Knowledge Graphs and Large Language Models to support a more extensible design review environment, and demonstrates its ability to retrieve and execute existing rules from the KG, capture new requests during design, and maintain a verifiable, adaptive compliance checking system.
Maen Alnuzha, Tanya Bloch· Journal of Information Techn...· 1 citation
In fast-evolving software systems, effective 'natural language requirements parsing' and downstream change effect analysis capability across a multitude of codes represents low-hanging-fruit in this regard. We present a structured framework to deploy Large Language Models (LLMs) for automating two essential software engineering tasks, namely requirement interpretation and change impact analysis Utilizing the inherent understanding of semantics offered by transformer-based LLMs, the novel approach advances by converting vague and unstructured requirement documents into structured but machine-readable specifications to offer a direct traceability mapping from requirements to system components. Additionally, the framework leverages LLM-driven dependency analysis to predict and quantify how change effects percolate through connected modules which can minimize manual effort and human errors. This approach combines prompt engineering and retrieval-augmented generation (RAG) for domain-relevant accuracy plus fine-tuning techniques. On open-source and enterprise-grade software projects, experimental evaluations show that disambiguation accuracy, traceability precision, and change impact coverage of our approach are orders of magnitude better than state-of-the-art rule-based or static analysis tools. Notes: The results illustrate the application of LLMs at scale and demonstrate how these can alter software engineering workflows by removing bottlenecks (at a massive scale) at different stages of the software development lifecycle. In this research, we provide a generalizable pipeline that helps to bridge the gap from NLP advancements into practice for software lifecycle management.
Nithya Krishnan, Kumaran Ramanujam, Suresh Babu Narra et al.· 2026 International Conferenc...· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
