Comprehension of the Unified Modeling Language is essential for learners in the context of software modeling. However, current UML learning tools provide minimal guidance to novice modelers as they are insufficient in analyzing modeling behaviour adopted during the diagram creation process. In order to address this gap, we present an enhanced version of UML Miner, a plugin for Visual Paradigm, that systematically records and analyzes UML modeling activities through the use of Process Mining techniques. UML Miner tracks all modeling events, resulting in event logs that warrant conformance checking against expert modeling practices. This tool establishes flexible, yet structured learning pathways through Declarative Process Mining, supporting trace-based and event-based filtering, customized violation reports, and integration with external process mining tools. This work emphasizes the potential of process mining in computing education, demonstrating how conformance checking can strengthen UML modeling proficiency.

Predicting whether a newly submitted bug will be resolved quickly or slowly is a crucial aspect of the bug triage process, as it enables project managers to estimate software maintenance efforts and manage development workflows more effectively. This paper proposes a deep learning approach for classifying bug reports into two categories— FAST or SLOW —based on their expected fixing time. The method leverages a feature set composed of the bug description and reporter comments and adopts a transfer learning strategy using pre-trained Large Language Models (LLMs). The problem is framed as a supervised text classification task, where LLMs exploit their ability to learn rich contextual representations of language. We introduce a novel classification workflow that guides the LLM through a structured prompt, combining two design patterns: the persona pattern to contextualize the task and the input semantic pattern to organize textual information. The workflow relies on zero-shot learning to assess whether the intrinsic knowledge embedded in the LLMs is sufficient for this prediction task. We conducted a comprehensive evaluation of three state-of-the-art LLMs across multiple real-world datasets sourced from Bugzilla, encompassing a diverse range of software projects. The experimental results demonstrate that the proposed method is effective in accurately identifying fast-resolving bugs. Among the evaluated models, LLaMA3-8B consistently delivered superior performance. Additionally, the absence of statistically significant performance variations across datasets highlights the generalizability of the approach. Notably, the LLMs maintained strong performance even on small and imbalanced datasets, underscoring their robustness and practical applicability in real-world, data-scarce scenarios.

Teaching the Unified Modelling Language (UML) is a critical task in the frame of Software Engineering courses. Teachers need to understand the students’ behavior along with their modeling activities to provide suggestions and feedback to avoid more frequent mistakes and improve their capabilities. This paper presents a novel approach for teaching the UML in Software Engineering courses, focusing on understanding and improving student behavior and capabilities during modeling activities. It introduces a cloud-based tool that captures and analyzes UML diagrams created by students during their interactions with a UML modeling tool. The key aspect of the proposal is the integration of a Retrieval Augmented Generation Large Language Model (RAG-based LLM), which generates insightful feedback for students by leveraging knowledge acquired during the modeling process.The effectiveness of this method is demonstrated through an experiment involving a substantial dataset comprising 5,120 labeled UML models. The validation process confirms the performance of the UML RAG-based LLM in providing relevant feedback related to entities and relationships in the students’ models. Additionally, a qualitative analysis highlights the user satisfaction, underscoring its potential as a valuable tool in enhancing the learning experience in software modeling education.

This paper proposes an approach to managing domain analysis in Software Product Lines (SPLs) using Decision Tables (DTs) that are adapted to the unique characteristics of SPLs. The adapted DTs enable clear and explicit representation of the intricate decisions involved in deriving each software product. Additionally, a method is presented for detecting and resolving anomalies that may disrupt proper product derivation. The effectiveness of the approach is evaluated through a case study, which suggests that it has the potential to significantly reduce development time and costs for SPLs. Future research directions include investigating the integration of SAT solvers or other methods to improve specific cases of scalability and conducting empirical validation to further assess the effectiveness of the proposed approach.

Defect prediction and estimation techniques play a significant role in software maintenance and evolution. Recently, several research studies proposed just-in-time techniques to predict defective changes. Such prediction models make the developers check and fix the defects just at the time they are introduced (commit level). Nevertheless, early prediction of defects is still a challenging task that needs to be addressed and can be improved by getting higher performances. To address this issue this paper proposes an approach exploiting a large set of features corresponding to source code metrics detected from commits history of software projects. In particular, the approach uses deep temporal convolutional networks to make the fault prediction. The evaluation is performed on a large data-set, concerning four well-known open-source projects and shows that, under certain considerations, the proposed approach has effective defect proneness prediction ability.

Identifying and diagnosing as early as possible malignant lung nodules is essential to reduce the mortality of lung cancer patients. Radiologists employ computer tomography scan to detect cancer in the body and track its growth. Interpretation of tomography scan, today still not automated, can lead to cancer detection at early stages, thus leading to the treatment of cancer which can decrease the death rates. Image processing, a branch of computer-assisted diagnostic, can support radiologists for the early detection of cancer. Against that background, we propose a novel ensemble-based approach for more accurate lung cancer classification using Computer tomography scan images. This work exploits transfer learning using pre-trained deep networks (e.g., VGG, Xception, and ResNet), combined into an ensemble architecture to classify clustered images of lung lobes. The approach is validated on a real dataset and shows that the ensemble classifier ensures effective performance, exhibiting better generalization capabilities.

Mobile devices have become, in the last years, an essential tool used to perform daily activities. However, they also have become the target of continuous malware attacks usually coming out from new malware obtained as a variant of existing ones. For this reason, we suppose that by comparing the behavior of a new application with those of known malware applications it is possible to define it as malicious or trusted. According to this, the current study proposes an approach based on a data-aware declarative process mining technique to identify similarities and recurring patterns in the system call traces generated by a set of malicious mobile applications. The obtained characterization, represented by a set of declarative constraints within their data attributes, can be considered as a run-time fingerprint of a malware useful to evaluate the membership of a new application to a given malware family. The empirical validation of the proposed approach is performed on a dataset of more than 1200 trusted and malicious applications coming out from eight malware families and the obtained results show a very good discrimination ability.

Novice programmers often encounter difficulties performing debugging tasks effectively. Even if modern development environments (IDEs) provide high-level support for navigating through code elements and for identifying the right conditions leading to the bug, debugging still requires considerable human effort. Programmers usually have to make hypotheses that are based on both program state evolution and their past debugging experiences. To mitigate this effort and allow novice programmers to gain debugging experience quickly, we propose an approach based on the reuse of existing bugs of open source systems to provide informed guidance from the failure site to the fault position. The goal is to help novices in reasoning on the most promising paths to follow and conditions to define. We implemented this approach as a tool that exploits the knowledge about fault and bug position in the system, as long as any bug of the system is known. The effectiveness of the proposed approach is validated through a quasi-experiment that qualitatively and quantitatively evaluates how the debugging performances of the students change when they are trained using the tool.

Comprehension of how students and developers head the development of software and what specific hurdles they face, have a strong potential to better support the coding workflow. In this paper, we present the CodingMiner environment to generate event logs from IDE usage enabling the adoption of fuzzy-based process mining techniques to model and to study the developers' coding process. The logs from the development sessions have been analyzed using the fuzzy miner to highlight emergent and interesting developers' and students' behaviors during coding. The mined processes show different IDE usage patterns for students with different skills and performances. To validate our approach, we describe the results of a study in which the CodingMiner environment is used to investigate the coding activities of twenty students of a CS2 course performing a given programming task during four assignments. Results also demonstrate that fuzzy-based process mining techniques can be effectively exploited to understand students and developers behavior during programming tasks providing useful insights to improve the way they code.

Process mining is a family of techniques that aim at analyzing business process execution data recorded in event logs. Conformance checking is a branch of this discipline embracing approaches for verifying whether the behavior of a process, as recorded in a log, is in line with some expected behavior provided in the form of a process model. In the literature, process mining techniques have already been used to study software development processes starting from logs derived from version management systems or from document management systems. In this paper, we use conformance checking to test coding behaviors starting from event logs generated from IDE usage. Understanding how developers carry out coding activities and what hurdles they usually face should provide useful tips for improving and supporting software development processes. In particular, through conformance checking, we can compare different process executions, and identify behavioral similarities and differences. In our experimentation, we evaluated the activities performed by 40 novice developers performing coding activities in 5 development sessions. We assessed the developers to distinguish the ones obtaining the best performance. We then compared the behavior extracted from this group of developers with the others. The results show different IDE usage patterns for developers with different skills and performance.

The birth of cloud-based development environments makes available an increasing number of data coming out from the interaction of different developers with a diverse level of expertise. This data, if opportunely captured and analyzed, can be useful to understand how developers head the coding activities and can suggest members of developers community how to improve their performances. This paper presents a framework allowing to generate event logs from cloud-based IDE. These event logs are then examined using a process mining technique to extract the developers' coding processes and compare them in the shared coding environment. The approach can be used to discover emergent and interesting developers' behavior. Thus, we compare the coding process extracted by developers with different skills. To validate our approach, we describe the results of a study in which we investigate the coding activities of forty students of an advanced Java programming course performing a given programming task-during four assignments. Results also prove that users with different performances possess distinct attitudes highlighting that the adopted process mining technique can be useful to comprehend how developers can improve their coding skills.

Software code life cycle is characterized by continuous changes requiring a great effort to perform the testing of all the components involved in the changes. Given the limited number of resources, the identification of the defect proneness of the software components becomes a critical issue allowing to improve the resources allocation and distributions. In the last years, several approaches to evaluating the defect proneness of software components are proposed: these approaches exploit products metrics (like the Chidamber and Kemerer metrics suite) or process metrics (measuring specific aspect of the development process). In this paper, a multi-source machine learning approach based on a selection of both products and process metrics to predict defect proneness is proposed. With respect to the existing approaches, the proposed classifier allows predicting the defect proneness basing on the evolution of these features across the project development. The approach is tested on a real dataset composed of two well-known open-source software systems on a total of 183 releases. The obtained results show that the proposed features have effective defect proneness prediction ability.