analyze change impact

Implementation discrepancies across software repository mining tools severely threaten the validity of empirical findings. Method: We conduct a dual-tool comparative analysis of 10 large-scale open-source projects, systematically identifying how minor implementation differences—such as commit parsing logic and author deduplication rules—induce up to 500% deviation in key metrics (e.g., commit count, developer count). We propose a “tool-level configuration + post-hoc normalization” co-optimization framework to mitigate metric divergence and perform multi-tool experiments, quantitative consistency assessment, and code-level root-cause analysis. Contribution/Results: We identify six technical sources undermining data validity and establish the first validity assessment paradigm for Mining Software Projects Research (MSPR) explicitly addressing tool heterogeneity—thereby enabling rigorous, reproducible, and comparable empirical software engineering studies.

This work addresses the pervasive issue of redundant and isolated messages in system logs, which hinder downstream tasks such as model reasoning and anomaly detection. To tackle this challenge, the authors propose LogPurifier—the first task-agnostic log cleansing framework—that systematically purifies logs by extracting log templates and modeling their dependencies to accurately identify and remove messages irrelevant to system functional behavior. By doing so, LogPurifier enables effective log sanitization applicable across diverse analytical scenarios. Experimental results demonstrate that LogPurifier substantially improves both accuracy and efficiency in various downstream tasks, thereby validating its effectiveness and generalizability.

This work addresses the growing complexity of CI/CD pipelines and the lack of structured analysis capabilities in existing tools for understanding their behavior, failures, and version evolution. The authors propose an innovative approach that uniquely integrates digital twin technology with BPMN-based modeling in DevOps contexts. By automatically parsing raw CI configurations and execution logs, the method constructs structured, high-level process models that enable pipeline visualization, failure traceability, and cross-version comparison. Evaluated across multiple open-source projects, the approach demonstrates effectiveness in monitoring, evolutionary analysis, and fault diagnosis, offering a modular and extensible foundational framework for the analysis and optimization of CI/CD pipelines.

Existing change impact analysis approaches rely solely on semantic similarity or structural dependencies, limiting their ability to comprehensively identify affected artifacts across heterogeneous software assets such as requirements, configurations, services, and tests. This work proposes a novel, training-free, and interpretable method that uniquely integrates semantic priors with multi-hop graph propagation. Specifically, it constructs a typed heterogeneous graph via static analysis, derives semantic priors from embedding-based cosine similarity, and diffuses impact through a row-normalized, decay-weighted propagation matrix controlled by a single parameter λ to balance precision and recall. Evaluation on five real-world change scenarios in a payment subsystem demonstrates the method’s capability to capture both structurally reachable yet textually disjoint artifacts and semantically related but structurally isolated ones, with demonstrated extensibility to operational assets such as container images and monitoring metrics.

This study presents the first empirical investigation into the evolution of CI/CD configurations in machine learning (ML) projects. Addressing the lack of understanding regarding how CI/CD configurations co-evolve with ML components, the authors analyze 508 open-source ML projects, 343 manually annotated commits, and 15,634 automated CI/CD commits. They propose a novel 14-category taxonomy capturing synergistic changes between CI/CD and ML components, develop a dedicated clustering tool to identify recurrent evolutionary patterns, and establish an empirically grounded model linking developer experience to CI/CD configuration modification behavior. Results show that 61.8% of CI/CD-related commits involve build strategy modifications; common anti-patterns—including dependency hardcoding and missing test frameworks—are identified; and senior developers modify CI/CD configurations more frequently and effectively than juniors, confirming the critical role of experience in CI/CD maintenance.

Existing database systems struggle to effectively model temporal dynamics, contextual dependencies, and causal relationships among attributes. To address this limitation, this work proposes Change Rules (CRs)—a novel rule-based paradigm that explicitly captures antecedent-consequent attribute changes within ordered tuple sequences, thereby overcoming the constraints of traditional data quality rules in modeling temporal and contextual patterns. The authors introduce CR-Miner, an efficient algorithm that employs a level-wise candidate generation strategy to identify change intervals, integrating declarative dependency specifications with sequence analysis techniques. Experimental results demonstrate that CR-Miner achieves a 40–50% average speedup over state-of-the-art methods while significantly enhancing the granularity and efficiency of trend analysis and causal inference.

This work addresses the challenge of accurately predicting downstream impacts of code changes in JavaScript, a language whose dynamic nature limits the effectiveness of traditional change impact analysis methods in both coverage and precision. To overcome these limitations, the authors propose Caprese, a novel framework that systematically integrates historical co-change mining with runtime dynamic dependency analysis, revealing their complementary strengths in change impact prediction. Caprese employs a hybrid recommendation strategy that fuses co-change patterns, dynamic program analysis, and multi-source signals. Evaluation on ten open-source Node.js projects demonstrates that while dynamic analysis achieves higher precision, historical analysis captures additional relevant changes missed by dynamic methods; their combination significantly enhances both the completeness and practical utility of impact recommendations.

This work addresses the inefficiency of existing deployment freeze policies, which fail to differentiate change risk during live events or rapid releases, and the limitations of conventional risk prediction approaches that rely on developer metadata or extensive historical data—raising privacy concerns and suffering from poor generalizability. To overcome these challenges, the authors propose a diff-aware risk assessment framework that extracts both quantitative and qualitative features, such as structural complexity, directly from code changes. Notably, it leverages large language models (LLMs) as cross-language feature extractors for risk prediction, eliminating dependence on language-specific tooling and preserving developer privacy. Empirical evaluation demonstrates the approach’s effectiveness, achieving an average recall of 0.83 and an F1-score of 0.81 on both Prime Video’s production environment and the ApacheJIT dataset, confirming its robustness across multi-language and multi-organizational settings.

This work addresses the high false positive rate (12.5%) and false negative rate (6.8%) of Mozilla’s existing T-test–based performance anomaly detection system, which hampers continuous integration efficiency. The authors introduce the first benchmark dataset comprising 174 engineer-annotated performance time series and conduct a systematic evaluation of 25 change-point detection algorithms combined with 15 ensemble strategies. They propose an ensemble voting mechanism that integrates offline, online, and hybrid methods to effectively mitigate the precision–recall trade-off. Experimental results and engineer feedback demonstrate that the proposed approach improves the F1-score by 11% over the original system and has been successfully integrated into Mozilla’s performance engineering infrastructure.

This study addresses the significant challenge of verifying termination in real-world C/C++ programs, where loop interactions and nondeterministic inputs complicate analysis. The authors propose a lightweight, tool-agnostic, source-level preprocessing approach that isolates loop obligations via loop slicing and enhances termination analysis by generating input-driven concrete variants tailored to specific scenarios. An empirical evaluation integrating six termination analyzers on 117 real programs demonstrates that slicing conservatively achieves structural isolation, while concretization improves detectability in targeted scenarios at the cost of reduced semantic coverage. Crucially, the combined effect of these techniques is non-additive, indicating that preprocessing should complement—rather than replace—analysis of the original program. The work further reveals substantial variation in how different analyzers respond to preprocessing, offering practical guidance for adaptive usage by developers.