Leveraging the code comprehension capabilities of Large Language Models (LLMs), we propose an automated approach to enhance Requirement-to-Code (R2C) traceability through Chain-of-Thought (CoT) prompting. Traditional Information Retrieval (IR) techniques (e.g., VSM, LSI) exhibit limited accuracy due to the semantic gap between natural language requirements and syntactic code structures. Our framework addresses this gap via two key innovations: (1) CoT-guided generation of functional code summaries through iterative reasoning steps (language identification, comment analysis, naming pattern interpretation), and (2) a similarity-based reordering strategy utilizing SimCSE embeddings to refine candidate links. Evaluations on four industrial datasets (iTrust, eTour, eANCI, SMOS) show $\mathbf{1 2 5. 4 7 \%,} \mathbf{6 3. 2 \%}$ and $\mathbf{6 2. 1 3 \%}$ average MAP improvements over LSI, FTLR+ and FQETLR+ baselines respectively. The approach demonstrates particular strength in low-coverage scenarios (106.19% average MAP improvement on eANCI). This study establishes novel approaches for LLM-driven traceability link recovery and provides actionable insights for integrating prompt engineering into software lifecycle tools.

Formal methods have been employed for requirements verification for a long time. However, it is difficult to automatically derive properties from natural language requirements. SpecVerify addresses this challenge by integrating large language models (LLMs) with formal verification tools, providing a more flexible mechanism for expressing requirements. This framework combines Claude 3.5 Sonnet with the ESBMC verifier to form an automated workflow. Evaluated on nine cyber-physical systems from Lockheed Martin, SpecVerify achieves 46.5% verification accuracy, comparable to NASA’s CoCoSim, but with lower false positives. Our framework formulates assertions that extend beyond the expressive power of LTL and identifies falsifiable cases that are missed by more traditional methods. Counterexample analysis reveals CoCoSim’s limitations stemming from model connection errors and numerical approximation issues. While SpecVerify advances verification automation, our comparative study of Claude, ChatGPT, and Llama shows that high-quality requirements documentation and human monitoring remain critical, as models occasionally misinterpret specifications. Our results demonstrate that LLMs can significantly reduce the barriers to formal verification, while highlighting the continued importance of human-machine collaboration in achieving optimal results.

Requirements engineering (RE) researchers have been experimenting with machine learning (ML) and deep learning (DL) approaches for a range of RE tasks, such as requirements classification, requirements tracing, ambiguity detection, and modelling. However, most of today’s ML/DL approaches are based on supervised learning techniques, meaning that they need to be trained using a large amount of task-specific labelled training data. This constraint poses an enormous challenge to RE researchers, as the lack of labelled data makes it difficult for them to fully exploit the benefit of advanced ML/DL technologies. This paper addresses this problem by showing how a zero-shot learning (ZSL) approach can be used for requirements classification without using any labelled training data. We focus on the classification task because many RE tasks can be framed as classification problems. The ZSL approach used in our study employs contextual word-embeddings and transformer-based language models (LMs). We demonstrate this approach through a series of experiments to perform three classification tasks: (1) FR/NFR — classification functional requirements vs non-functional requirements; (2) NFR — identification of NFR classes; (3) Security — classification of security vs non-security requirements. The study shows that the ZSL approach achieves an F1 score of 0.66 for the FR/NFR task. For the NFR task, the approach yields F1∼0.72−0.80, considering the most frequent classes. For the Security task, F1 ∼0.66. All of the aforementioned F1 scores are achieved with zero-training efforts. This study demonstrates the potential of ZSL for requirements classification. An important implication is that it is possible to have very little or no training data to perform classification tasks. The proposed approach thus contributes to the solution of the long-standing problem of data shortage in RE.

In recent years, advanced deep learning language models such as BERT, ELMO, ULMFiT and GPT have demonstrated strong performance on many general natural language processing (NLP) tasks. BERT, in particular, has also achieved promising results on some domain-specific tasks, including the requirements classification task. However, in spite of its great potential, BERT under-performs on domain specific tasks. In this paper, we present BERT4RE, a BERT-based model retrained on requirements texts, aiming to support a wide range of requirements engineering (RE) tasks, including classifying requirements, detecting language issues, identifying key domain concepts, and establishing requirements traceability links. We demonstrate the transferability of BERT4RE, by fine-tuning it for the task of identifying key domain concepts. Our preliminary study shows that BERT4RE achieved better results than the BERTbasemodel on the demonstrated RE task.

We propose a user-oriented language to enable users to specify interconnections between heterogeneous objects in the Internet of Things (IoT). Based on the idea of the use case specification technique in software engineering, our language provides users with a natural language like syntax to allow them to specify when or under what conditions they want which objects to be connected. To support this language, we have also developed a transformation mechanism that automatically translates users' specification into the source code. We have evaluated this language through an experiment and a survey. The main contributions of this paper are: 1) a simple natural language that enables the users to specify which objects to connect and when and 2) a transformation mechanism that automatically translates users' specifications into source code and dynamically attaches the code to relevant applications. This paper represents a first step in bringing the IoT closer to their users.

Context: End-user service composition (EUSC) is a service-oriented paradigm that aims to empower end users and allow them to compose their own web applications from reusable service components. User studies have been used to evaluate EUSC tools and processes. Such an approach should benefit software development, because incorporating end users’ feedback into software development should make software more useful and usable. Problem: There is a gap in our understanding of what constitutes a user study and how a good user study should be designed, conducted, and reported. Goal: This article aims to address this gap. Method: The article presents a systematic review of 47 selected user studies for EUSC. Guided by a review framework, the article systematically and consistently assesses the focus, methodology and cohesion of each of these studies. Results: The article concludes that the focus of these studies is clear, but their methodology is incomplete and inadequate, their overall cohesion is poor. The findings lead to the development of a design framework and a set of questions for the design, reporting, and review of good user studies for EUSC. The detailed analysis and the insights obtained from the analysis should be applicable to the design of user studies for service-oriented systems as well and indeed for any user studies related to software artifacts.

Identifying relationships between requirements described in natural language (NL) is a difficult task in requirements engineering (RE). This paper presents a novel approach that uses Semantic Frames in FrameNet to find the relationships between requirements. Our initial validation shows that the approach is promising, with an F-Score of 83%. Our next step is to use the approach to identify implicit requirements relationships and finding requirements traceability links.

Software requirements are typically written in natural language, which need to be transformed into a more formal representation. Natural language processing techniques have been applied to aid in this transformation. Semantic parsing, for instance, adds semantic structure to text. It however requires supporting corpora which are still missing in requirements engineering. To address this gap, we developed FN-RE, a corpus of requirements documents, which was annotated based on semantic frames in FrameNet. Each requirement statement was manually labelled by two annotators by selecting suitable semantic frames and related frame elements. We obtained an average agreement of 72.85% between the two annotators, measured by F-score, thus indicating that the annotations provided in our corpus are reliable.

Mobile application (app) websites such as Google Play and AppStore allow users to review their downloaded apps. Such reviews can be useful for app users, as they may help users make an informed decision; such reviews can also be potentially useful for app developers, if they contain valuable information concerning user needs and requirements. However, in order to unleash the value of app reviews for mobile app development, intelligent mining tools that can help discern relevant reviews from irrelevant ones must be provided. This paper surveys the state of the art in the development of such tools and techniques behind them. To gain insight into the maturity of the current support mining tools, the paper will also find out what app development information these tools have discovered and what challenges they are facing. The results of this survey can inform the development of more effective and intelligent app review mining techniques and tools.

To support the migration of software applications to the cloud environment, cloud venders have proposed different migration methodologies and guidelines. Yet, most of them require human intervention, involving manually performing repetitive tasks. This paper proposes a pattern-based transformation approach for cloud application migration. The approach automatically modifies the source code of an application before the migration, to make it cloud-ready, and then transforms the source code to the target code in the cloud environment. The approach is supported by three key elements (patterns, rules and templates) and a process that systematically applies these elements. First, a pattern matching engine based on a regular expression processing technique is used to identify the parts of the source code that require modification and to extract the essential tokens from the source code for code transformation. Next, transformation rules are invoked to change the source code into the target code using a template, designed according to the target cloud environment. The proposed approach has been demonstrated on 19 open-source projects, by migrating them to Amazon Web Services.

This paper presents a systematic literature review of end-user service composition. It reviews current activities performed by end users, and tools and approaches that enable them to compose and develop service systems from Web Services. The paper also highlights some key open research issues for the future.

With the rapid development of Web 2.0 and its related technologies, more and more end-users start to participate in the development of World Wide Web. Yet, not enough attention from both academics and industries has been paid to allowing them to compose services to assist their daily work. This is mainly due to the lack of a high-level abstraction that defines what concepts, functions, and system components a platform should equip to support end-user service composition. This paper first defines the crucial requirements of end-user friendly service composition tools, and then presents End-User Service Composition Model, a platform-independent meta-model that serves as a basis for the design and development of such an end-user friendly platform based on these requirements. Finally, the paper applies this meta-model to four existing end-user service composition platforms to see if they meet these requirements.

With the rapid growth of Web 2.0 and its related technologies, more and more composite services have been created by end-users. In the traditional composite service development workflow, the composite service descriptions have always to be manually written by end-users as soon as the services are either created or modified. As a result, these handcrafted descriptions could be irrelevant or out-of-date to the corresponding composite services. Also, the users who speak other languages can hardly understand the languages used in these descriptions. Therefore, we present an approach that automatically generates context-aware descriptions for composite services to improve the workflow of composite service development as a means of overcoming the drawbacks exposed in traditional end-user service composition workflows.

The emergence of Web 2.0 and its related technologies such as HTML5 has empowered the end users and made it possible for them to compose their own Web applications. Yet, most of the current development has mainly concentrated on the support of the composition of enterprise-oriented services and scientific workflows, with not enough effort made to support the composition of end user-oriented services. This paper presents HyperMash, a service composition approach for the end users. The salient feature of this approach is its support of on demand heterogeneous service composition, which allows the end users to create their own composite services by combining RESTful services with SOAP-based services at runtime. In addition, to make it easier for the end users to compose RESTful services, HyperMash provides a full set of RESTful interface features. The paper describes the conceptual framework and working principles of HyperMash and illustrates the HyperMash approach through two examples.

Tool support for automatically constructing analysis models from the natural language specification of requirements (NLR) is critical to model driven development (MDD), as it can bring forward the use of precise formal languages from the coding to the specification phase in the MDD lifecycle. TRAM provides such a support through a novel approach. By using a set of conceptual patterns to facilitate the transformation of an NLR to its target software model, TRAM has shown its potential as an automated tool to support the earliest phase of MDD. This paper describes TRAM and evaluates the tool against three benchmark approaches.

Early software development approaches focused on program code as paramount, paying little attention to any analysis or understanding of its generative real-world context and needs. More modern problem-oriented approaches view software development as problem solving, and use many of the rich toolset and techniques of the knowledge engineering (KE) area. ‘When one encounters a new situation (or makes a substantial change in one's view of the present problem) one selects from memory a structure called a Frame. This is a remembered framework to be adapted to fit reality by changing details as necessary’. ‘We intuitively believe that experienced problem solvers construct new systems by modifying known systems’. Both Problem Frames and Domain Theory use modelling as a means for problem understanding and representation. In this respect, they are akin to the Common KADS framework (Breuker & van de Velde, 2004) that provides a suite of re-usable knowledge models for expert systems development. According to Studer et al. (1998), modelling marks an important transition from first-generation to second-generation expert systems, as the modelling approach to knowledge engineering had taken over the knowledge transfer approach. Problem-oriented approaches to software development have two essential attributes. Firstly, they recognise the need to work iteratively between real-world problem and software solution to increase understanding: solutions are sometimes straw men, allowing the developer to reflect on the problem to understand it better. Indeed, the importance of this knowledge building process in design has been widely acknowledged (Alexander, 1979; Dasgupta, 1991). Secondly, they view software development as problem solving and knowledge reuse. This special section collects the best papers presented at the International Workshop on Advances and Applications of Problem Orientation, held in Cape Town, South Africa, in May 2010. These papers represent a snapshot of current research and practice in problem-oriented approaches to software development. In the first paper, Luigi Lavazza addresses the problem that during analysis and development user requirements are elicited and perceived at various levels of abstraction, by proposing a systematic approach to relating such diverse requirements through the establishment of requirements hierarchies. The work is situated within Problem Frames and applied to a comprehensive case study. The work is particularly relevant to addressing business problems in which a need arises to relate business goals to software requirements. In the second paper, Xinyu Wang and his colleagues present an approach that guides a business analyst to derive a set of problem frames from a given problem description. The approach contains three steps. In the first step, business process models are developed to capture the behavioural view of the problem context. In the second step, object analysis models are used to capture the structural view of the problem context. Together, these two views collectively and comprehensively capture the early context knowledge. These two types of model are then used in a third step to construct context diagrams and problem frames. Finally, Jelena Marincic and her colleagues address the problem of how to construct adequate problem models, the starting point of solution seeking, through methods that properly account for both formal and informal modelling decisions and steps. Their approach is located within an industrial setting and the development of embedded systems. Action research was applied in such a setting to help improve problem analysis and problem model validation. Collectively, this special section aims to give a flavour of current thinking in this important area of research and practice. We hope this special section will continue to stimulate the debate and discussion.

SUMMARY Although quality requirements (QRs) have become a major drive in today's software development, there have been very few real‐world examples in the literature that demonstrate how to meet these requirements. This paper presents such an example. Specifically, the paper describes the design of a partition‐based distributed stock trading service system that satisfies a set of QRs related to resource utilization, performance, scalability and availability. The paper evaluates this design through detailed experiments and discusses some design alternatives and the lessons learned. Central to this design are a static load distribution strategy and a dynamic load balancing strategy. The first strategy is to achieve an initial balanced workload on the system's server cluster during the system initialization time, whereas the second strategy is to maintain this balanced workload throughout the system execution time. Together, these two strategies work in unison to ensure that the server resources are efficiently utilized; the user requests are processed with the required speed; the application is partitioned with sufficient room to scale; and the system is highly available. Copyright © 2011 John Wiley & Sons, Ltd.

Software problems originate from real world problems. A software solution must address its real world problem in a satisfactory way. A software engineer must therefore understand the real world problem that their software intends to address. To be able to do this, the software engineer must understand the problem context and how it is to be affected by the proposed software, expressed as the requirements. Without this knowledge the engineer can only hope to chance upon the right solution for the problem. Application of problem-oriented approaches may well be a way of meeting this challenge.

Service-oriented computing promises to create flexible business processes and applications on demand by dynamically assembling loosely coupled services within and across organizations. Quality requirements play a central role in service sourcing and, together with Service Level Agreements, facilitate service selection and measurement of service delivery effectiveness. This empowers customers to make better decisions when faced with multiple service offerings and varying service costs. However, existing business process modeling languages provide little support for quality requirements annotation and specification. This paper argues that quality requirements are a central aspect of business process modeling specification, and thus proposes to incorporate time, cost and reliability quality requirements as extensions to the Business Process Modeling Notation (BPMN). These quality requirements are evaluated based on analytical model using reduction rules. An example of online purchasing business process is illustrated to demonstrate the applicability of the proposed approach.

The OSGi service specification defines an open service platform for service delivery, composition and execution in networked environments. The specification, however, is limited to a single java virtual machine (JVM) and does not define the distribution and mobility of services across different OSGi platforms and devices. This paper first revisits the fundamentals of OSGi service distribution, clarifies and defines a terminology for OSGi service mobility and distribution. It then proposes to extend the current OSGi platform with service distribution and service mobility that aim to support three important requirements on ubiquitous applications, namely, spontaneous interoperability, mobility and software adaptability. The paper demonstrates these extensions through several prototype implementations. These extensions are supported through a common framework, which targets at ubiquitous environments and aims to facilitate the construction of OSGi applications that span multiple OSGi platforms, multiple JVMs and multiple devices. In addition, the proposed framework offers two special features: First, it supports automatic contextual management through a virtual global shared space whose content is automatically and dynamically adjusted to reflect the changes in the system and the mobile environment; Second, it supports different OSGi bundle and service mobility paradigms. The proposed framework blurs the distinction between local and remote services, where remote services can be accessed as if they were local, which greatly simplifies application development. We believe existing OSGi platform distribution solutions can also be supported by this framework.

In order to perform a function mapping task, a neural network needs two supporting mechanisms: an input and an output training vector, and a training regime. A new approach is proposed to generating a family of neural networks for performing a set of related functions. Within a family, only one network needs to be trained to perform an input-output function mapping task and other networks can be derived from this trained base network without training. The base net thus acts as a generator of the derived nets. The proposed approach builds on three mathematical foundations: (1) symmetry for defining the relationship between functions; (2) weight transformations for generating a family of networks; (3) Euclidian distance function for measuring the symmetric relationships between the related functions. The proposed approach provides a formal foundation for systemic information reuse in ANNs.

This paper describes a set of symmetry transformations (STs) that enable a base net to generate the weights of derived nets. The derived nets then map related functions. This process is aligned to equivalence relationships. This allows information reuse and integration to be aligned to specific equivalence relationship axioms. The paper focuses on early (initial) results. The approach introduces two mathematical techniques: symmetry transformations and a distance function, it also contributes to the connectionist domain by aligning weight transformations to equivalence relations, it develops an alternative way of reusing information which used symmetry transforms for generating a hierarchy of neural networks.

A heuristic approach, ZEST for ESTimator, is developed to analyze bus driver scheduling problems and produce an estimate of the number of drivers required for a bus schedule. Based on the observation that the maximum number of drivers is needed in the morning and afternoon peaks, ZEST divides the driver scheduling problem into morning and afternoon subproblems, solves each subproblem separately, and, finally, combines the solutions. The key techniques in ZEST derive from manual scheduling operations that examine the critical decision points in a bus schedule that are vital for a good driver schedule and use these decision points to develop chains of meal breaks that dovetail one driver's meal break with another driver's. ZEST can be used as a standalone estimator of driver duties or as a component of other driver scheduling approaches