S. Rathore

Traversal-Aware Structural Fusion of AST and CFG for Code Representation Learning in Software Fault and Code Smell Detection

The effectiveness of machine learning and deep learning models in software engineering (SE) tasks, such as fault prediction and code smell detection, depends heavily on the quality of source code representation and feature extraction. Previous studies have primarily used abstract syntax trees (ASTs) for source code representation in SE tasks but often fail to capture crucial semantic and control-flow details. To overcome this, control-flow graphs (CFGs) and combined representations (AST+CFG) have been explored for richer code understanding. However, their tradeoffs and benefits on the prediction models for SE tasks remain largely unexplored. This study investigates the impact of different source code representation techniques, including AST, CFG, their combination (AST+CFG), and pretrained code models (CodeBERT and Code2Vec) in software fault prediction and code smell detection. In addition, we investigate different traversal methods, including root-to-leaf and leaf-to-leaf, for both AST and CFG and their combination (AST+CFG) to assess their effectiveness in capturing structural and semantic information for improving prediction model performance. The experimental analysis is performed using the seven projects in the PROMISE dataset for fault prediction and the Multilabel Code Quality dataset for code smell detection. We employ various machine learning techniques for prediction model building and different performance measures for a comprehensive evaluation. The results show that a combined AST+CFG representation outperforms individual representations (AST or CFG) by providing a more comprehensive view of structural and control-flow semantics. In addition, CodeBERT stands out in both domains, demonstrating its ability to capture deeper relationships in the code. However, pretrained models were found to be more computationally expensive.

Adaptive Just-in-Time software defect prediction using unsupervised concept drift detection

An Analysis of Student Perceptions and Learning Impact of Large Language Models in Requirements Engineering Education

Nowadays, large language models (LLMs) are increasingly used in software engineering education. However, evidence regarding their pedagogical value for improving Requirements Engineering (RE) education remains scant. Past research has largely relied on small-scale or tool-centric evaluations, which are limited in their ability to provide meaningful insights into students' perceptions and learning impact, necessary to guide the systematic integration of LLMs into curricula. This work investigates the impact of using LLMs as co-analysts on student learning outcomes, student perceptions, and pedagogical feasibility in undergraduate RE education. In a controlled experiment, we involved 238 undergraduate students studying Software Engineering. We assigned participants the manual and LLM-assisted RE tasks and had them work on three RE learning activities: stakeholder analysis, development of user stories, and requirement prioritization and conflict detection. The learning outcomes were assessed by structured rubrics addressing the quality of created artifacts, while student perceptions were measured through post-activity surveys and feedback forms. Additionally, emotion and thematic analyses were performed to identify events that triggered these emotions. Results suggest that LLM-supported co-analysis positively impacts student-created RE artifacts in terms of quality and consistency, particularly when addressing early-level problems or when used to convey structural information, while human insight remains critical for refinement and strategic-level cognitive processes. Emotion analysis shows a general acceptance with productive hesitancy, implying that LLMs are better off as human-guided co-analysts in RE education.