Like any other discipline, Large Language Models (LLMs) have significantly impacted software engineering by helping developers generate the required artifacts across various phases of software development. This paper presents a case study comparing the performance of popular LLMs—GPT, Claude, Gemini, and DeepSeek — in generating functional specifications that include use cases, business rules, and collaborative workflows for a web application, the Mess Management System. The study evaluated the quality of LLM-generated use cases, business rules, and collaborative workflows in terms of their syntactic and semantic correctness, consistency, non-ambiguity, and completeness compared to the reference specifications against the zero-shot prompted problem statement. Our results suggested that all four LLMs can specify syntactically and semantically correct, mostly non-ambiguous artifacts. Still, they may be inconsistent at times and may differ significantly in the completeness of the generated specification. Claude and Gemini generated all the reference use cases, with Claude achieving the most complete but somewhat redundant use case specifications. Similar results were obtained for specifying workflows. However, all four LLMs struggled to generate relevant Business Rules, with DeepSeek generating the most reference rules but with less completeness. Overall, Claude generated more complete specification artifacts, while Gemini was more precise in its generated specifications.

Context: Coding is an incremental activity where a developer may need to understand a code before making suitable changes in the code. Code documentation is considered one of the best practices in software development but requires significant efforts from developers. Recent advances in natural language processing and machine learning have provided enough motivation to devise automated approaches for source code documentation at multiple levels. Objective: The review aims to study current code documentation practices and analyze the existing literature to provide a perspective on their preparedness to address the stated problem and the challenges that lie ahead. Methodology: We provide a detailed account of the literature in the area of automated source code documentation at different levels and critically analyze the effectiveness of the proposed approaches. This also allows us to infer gaps and challenges to address the problem at different levels. Findings: (1) The research community focused on method-level summarization. (2) Deep learning has dominated the past five years of this research field. (3) Researchers are regularly proposing bigger corpora for source code documentation. (4) Java and Python are the widely used programming languages as corpus. (5) Bilingual Evaluation Understudy is the most favored evaluation metric for the research persons.

Abstract The flexibility of the use cases in specifying requirements from informal textual descriptions to more formal ones makes them usable in different contexts and purposes. However, the versatility of use cases regarding their admissible structure raises a natural concern about the specification completeness. This paper reports on the analysis of the eight different variants of use case template regarding their functional completeness, ability to express the set of particular functionalities, by comparing their information contents exercised by comprehensive questionnaires on five different problem specifications. The questionnaire was obtained from two sources: one based on the understanding of the functionality to be implemented and the other based on the functionality documented in eight different use case templates under study. Our results suggested that use cases can be used to specify a complete set of requirements intended to develop a software system. We found that the choice of a use case template influences the completeness of the specification. A more detailed analysis of the eight different variants of use case template resulted in the identification of 21 significant use case elements. We showed that by incorporating these significant use case elements in a given template, the completeness of the specification could be further enhanced.

Rapid growth in providing automated solutions resulted in large code bases to get quickly developed and consumed. However, maintaining code and its subsequent reuse pose some challenges here. One of the best practices used to handle such issues is also to provide suitable text summary of the code to allow the human developers to comprehend the code easily, but this can be quite time-consuming and costly affair. A few efforts have been made in this direction where the text summary of the code either generated from the method signature or its body. In this paper, we propose a text summarization approach for Java code that makes use of identification of code level nano-patterns to obtain text summary. The approach also looks for associations between these nano-patterns in a Java method code and then use a template based text generation to obtain the final text summary of the Java method. We evaluated the summary generated by the proposed approach using a controlled experiment with other three existing approaches. Our results suggested that the summary generated by our approach was better on the part of completeness and correctness criteria. The feedback obtained during the experimental validation suggested additional inputs to improve the generated text summary on the other two accounts as well.

Analysis modeling refers to the task of identifying domain objects, their attributes and operations, and the relationships between these objects from software requirements specifications which are usually written in some natural language. There have been a few efforts to automate this task, but they seem to be largely constrained by the language related issues as well as the lack of a systematic transformation process. In this paper, we propose a systematic, automated transformation approach which first interprets the specification sentences based on the Hornby's verb patterns, and then uses semantic relationships between the words in the sentences, obtained from Type Dependencies using Stanford NL Parser, to identify the domain elements from them. With the help of a controlled experiment, we show that the analysis class diagrams generated by the proposed approach are far more correct, far more complete and less redundant than those generated by the exiting automated approaches.

This paper presents AnModeler, a tool for generating analysis models from software requirements specified using use cases. The tool uses the Stanford natural language parser to extract type dependencies (TDs) and parts of speech tags (POS-tags) of sentences from input Use Case Specification (UCS). Then, it identifies sentence structures using a set of rules framed based on Hornby's verb patterns. With the information of the TDs, POS tags, and the identified sentence structures, the tool discovers domain elements, viz.: domain objects (including their attributes and operations) and interactions between them; it consolidates the domain information as a class diagram (as well as a sequence diagram). An experiment conducted on 10 UCSs with two industry experts as subjects showed that the analysis class diagrams generated by AnModeler were remarkably close to those generated by the two industry experts. Being lightweight and easy to use, the tool can also be used to assist students and young developers in acquiring object-oriented domain modeling skills quickly.

This paper presents the results of an experimental study, in which four open source static program analysis tools namely, FindBugs, CodePro Analytix, UCDetector, and PMD have been applied on four small Java projects to appraise the bug detection effectiveness and efficiency on mutation bugs. In this experiment, we generated multiple applicable mutants of each projects using MuJava tool and subsequently applied the four SPA tools to measure the bug detecting effectiveness and efficiency. The obtained data was analyzed on two different bug classifications, namely mutant based and severity based. Our results showed that PMD demonstrated the maximum bug detecting effectiveness as well as efficiency among the four SPA tools, whereas CodePro Analytix identified bugs at all category of severity including most of the high severity bugs.

Web applications have become a very popular means of developing software. This is because of many advantages of web applications like no need of installation on each client machine, centralized data, reduction in business cost etc. With the increase in this trend web applications are becoming vulnerable for attacks. Cross site scripting (XSS) is the major threat for web application as it is the most basic attack on web application. It provides the surface for other types of attacks like Cross Site Request Forgery, Session Hijacking etc. There are three types of XSS attacks i.e. non-persistent (or reflected) XSS, persistent (or stored) XSS and DOM-based vulnerabilities. There is one more type that is not as common as those three types, induced XSS. In this work we aim to study and consolidate the understanding of XSS and their origin, manifestation, kinds of dangers and mitigation efforts for XSS. Different approaches proposed by researchers are presented here and an analysis of these approaches is performed. Finally the conclusion is drawn at the end of the work.

A software is associated with certain modes of failure. Occurrence of such failures may be hazardous for the regular functioning of the software. Majority of these failures occur because of the unforeseen faults that manifest themselves during the execution of the software. The contemporary trends in the software industry indicate dedicated efforts to minimize these unforeseen faults, thereby minimizing the chances of unforeseen failures. One of the definitive ways is to analyze the specifications thoroughly for the potential faults it may contain. Fault tree analysis (FTA) is one such approach that scans the specifications to identify potential failure modes and has been used successfully in many domains including software. In this paper, we propose an approach to generate test cases from UML activity diagram specifications by first transforming an activity diagram into a Software Success Tree (SST) and a Software Fault Tree (SFT). Subsequently, the SST and the SFT are then used to generate test cases for testing the normal and exceptional behavior of the system, respectively. We demonstrate the applicability of the proposed approach using an illustrative example and compare its effectiveness with the other activity diagram based test case generation techniques.

Use case models, that include use case diagrams along with their documentations, are typically used to specify the functional requirements of the software systems. Use cases are usually semi-structured and documented using some natural language hence issues like ambiguity, inconsistency, and incompleteness are inevitably introduced in the specifications. There have been many efforts to formalize the use case template that make use of certain grammatical construction to guide the structure or style of the description. This paper describes an empirical work to assess the usefulness of eight such use case templates against a set of five judging criteria, namely, completeness, consistency, understandability, redundancy and fault proneness. We conducted a controlled experiment where a group of postgraduate students applied these use case templates on multiple problem specifications. In our results, Yue's template was found to be more consistent and less fault prone, Cockburn's template was found to be more complete and more understandable and, Tiwari's template was found to be less redundant as compared to the other use case templates, though the results were not statistically significant.

This paper proposes a technique for characterization of the frequency-dependent losses in a wireline communications link. By using the measured jitter at the output of a receiver front-end as its only input, this method is able to estimate both the pulse response and frequency response of the link, including the effects of the transmitter output, the channel itself, and the receiver front-end. Simulated and measured results verify the accuracy of this technique, which can be used to efficiently adapt the settings of critical circuit blocks in the link, such as equalizer tap weights.

In this paper, we empirically investigate the re-lationship of existing class level object-oriented metrics with fault proneness over the multiple releases of the software. Here we first, evaluate each metric for their potential to predict faults independently by performing univariate logistic regression analysis. Next, we perform cross-correlation analysis between the significant metrics to find the subset of these metrics for an improved performance. The obtained metrics subset was then used to predict faults over the subsequent releases of the same project datasets. In this study, we used five publicly available project datasets over their multiple successive releases. Our results reported that the identified subset metrics demonstrated an improved fault prediction with higher accuracy and reduced misclassification errors.

In this paper, we propose an approach for transforming use case requirements into actor-oriented activity charts. In this approach, we first specify requirements using a relatively more formalized use case template. Next, we generate actor-oriented activity charts by identifying various interactions of an actor with the system and the events sequenced thereafter. The resulting activity charts can be useful in various software planning and development activities like release planning, test planning, execution and others.

Designing high speed Double Data Rate (DDR) memory interface controller in low cost wire-bond packages is a difficult goal to achieve. The interface is limited at speed because of various factors such as Inter Symbol Interference (ISI), Power Delivery Network (PDN) noise, Cross talk etc. At high speeds like 1Gbps, Pattern dependent effects have a major role to play in DDR link budget analysis. Hence, selecting the right data pattern for DDR interface characterization becomes an important problem to solve. Little data exists on what patterns to use for DDR bus characterization and still lesser silicon data exists. This paper is an attempt to create an analysis technique to characterize high speed DDR interfaces. A set of data patterns is proposed. They can be used to characterize any source synchronous parallel bus interfaces like DDR etc. These data patterns simultaneously capture the effects of ISI, PDN noise and Cross talk, the major sources of noise or uncertainty in this case. We have built a case for proving that these patterns are indeed the worst from DDR timing prospective. DDR design space can thus be reduced by concentrating on these worst case data patterns only as compared to the complete set of patterns. Further, silicon results are shared, to prove the efficiency of our approach.

Code inspection and unit testing are two popular fault- detecting techniques at unit level. Organizations where inspections are done generally supplement it with unit testing, as both are complementary. A natural question is the order in which the two techniques should be exercised as this may impact the overall effectiveness and efficiency of the verification process. In this paper, we present a controlled experiment comparing the two execution-orders, namely, code inspection followed by unit testing (CI-UT) and unit testing followed by code inspection (UT-CI), performed by a group of fresh software engineers in a company. The subjects inspected program-units by traversing a set of usage scenarios and applied unit testing by writing JUnit tests for the same. Our results showed that unit testing can be more effective, as well as more efficient, if applied after code inspection whereas the later is unaffected of the execution- order. Overall results suggest that sequence CI-UT performs better than UT-CI in time-constrained situations.

Test driven development (TDD) is an approach for developing programs incrementally by first writing tests and then writing enough code to satisfy them. Though there have been some experiments for evaluating TDD on smaller scope, its impact on a larger scope of program development activities needs to be investigated. In this work, we evaluate the impact of TDD on various program development activities like designing, coding, and testing, through a controlled experiment where we compare it with the conventional way of developing the code. In a single-factor block design, two groups of students developed two moderately sized programs following the two development-styles under study. Our results suggest that TDD helps in reducing overall development effort and improving developer's productivity whereas the code quality seems to be affected by the actual testing efforts applied during a development-style.

The main objective of a 'design by contracts' approach as applied to object-oriented systems, is to develop complete and consistent method contracts for the objects of the system. In this work, we propose a practical approach to develop these contracts for an object from its annotated structural representation, namely, UML constrained class diagram. We generate, simulate, and refine an object state-chart from an initial set of method contracts which in turn help further validating and enhancing these contracts. The impact of this analysis can be multifold: first, it identifies various discrepancies like incomplete and inconsistent class specifications, second, a correct and consistent object statechart model is obtained from which reliable automated code and unit tests can easily be generated, third, facilitate essential and effective verification for software re-use, forth, the resulting statechart and class specifications are in a lock-steps which facilitates effective incremental development and change management and fifth, it allows a modeler to specify object's dynamic requirements declaratively on an abstract level, without the need to use full operational dynamic diagrams. We have also designed a tool ObjectSim that performs automated statechart generation and their interactive simulations. We demonstrate our approach using an example and discuss other related issues.

Purpose The objective of this study is to gather information about information technology (IT) related security issues in small firms in both manufacturing and service. Design/methodology/approach Despite its widely acknowledged importance, the academic research in the area of information systems security issues for small businesses is almost negligible. To fill this gap, a questionnaire was mailed to 1,000 small business owners in Lynchburg, Virginia, USA, and 138 valid responses were received. Findings The results of this study indicate that the small business owners may have procedures and policies in place and may use technologies to counteract the security threat, but this research raised doubts about their effectiveness. Originality/value The data collected through this research will help small business organizations in planning, training, and exploitation of IT.

Dedicated hardware previously has been required to perform real-time MPEG-2 video encoding. However, with increases in clock frequency and the introduction of video-specific instruction sets, general-purpose processors can now approximate the function and performance of single-function hardware. In this paper, we describe a software-only MPEG-2 (MP@ML) video encoder implemented on a personal computer using an Intel/sup TM/ Pentium(R) III processor. This encoder is capable of real-time operation while consuming less than 70% of the processor. The main contribution of this work is a set of algorithmic simplifications that significantly reduces the computational load of the encoding process while only slightly degrading the subjective video quality compared to encoders that are more exhaustive.