build scalable backend services

Distributed concurrent execution of microservices in cloud environments frequently induces race conditions; however, existing detection techniques suffer from high intrusiveness and poor adaptability to cross-service interactions. Method: This paper proposes a non-intrusive, automated concurrency vulnerability detection framework that leverages runtime library-level dynamic instrumentation and distributed tracing to model cross-service happened-before relationships and resource access patterns, coupled with a three-stage validation mechanism for precise, code-modification-free identification and localization of race conditions. Contribution/Results: Evaluated on an industrial-grade open-source microservice benchmark, our approach achieves significantly higher detection rates and substantially lower false-positive rates compared to state-of-the-art methods, while demonstrating strong architectural adaptability across diverse microservice deployments.

Concurrency bugs—arising from improper synchronization of shared resources—pose severe reliability threats to multithreaded and distributed systems, yet remain notoriously difficult to detect and localize precisely. This paper introduces the first deep learning framework for concurrent bug detection and code-level precise localization. First, we construct a large-scale, diverse, and domain-specific dataset of concurrency bugs. Second, we design a concurrency-aware Code Property Graph (CCPG) and an associated heterogeneous Graph Neural Network (GNN) that explicitly models critical semantic features, including thread interactions, lock ordering, and data races. Third, we integrate SubgraphX, a model-agnostic explainability technique, to enable end-to-end transition from binary classification to line-level fault localization. Experimental evaluation demonstrates that our approach achieves average improvements of 10% in accuracy and precision, and 26% in recall over state-of-the-art methods.

Automatically repairing data races in industrial-scale shared-memory concurrent programs—particularly Go-based microservices—remains highly challenging due to complex concurrency semantics and context-sensitive interference patterns. Method: This paper introduces the first end-to-end repair framework that tightly integrates large language models (LLMs) with precise program analysis. It combines static analysis, interprocedural data-flow tracking, concurrency-aware LLM prompting, and domain-informed code generation to accurately identify and safely fix intricate data race patterns. Contribution/Results: Deployed at Uber for 18 months, the framework automatically generated 224 patches addressing 55% of known data races; 86% were approved by developers and merged into the mainline. This significantly improves reliability and repair efficiency in high-concurrency production systems.

BDI programming systems suffer from inconsistent concurrency support and poor customizability, hindering framework selection and extensibility. This paper introduces the first unified taxonomy of concurrency models for BDI frameworks, formally defining a multidimensional assessment framework for customization capabilities. Through an empirical comparative study, we systematically model and evaluate the concurrency mechanisms of prominent frameworks—including Jason, 2APL, and Jadex—identifying critical design trade-offs and limitations. We propose a reusable classification framework that exposes common deficiencies across these systems, particularly in scheduling granularity, intervention depth, and configuration flexibility. Our analysis provides both theoretical foundations and practical guidelines for designing highly controllable, configurable, and concurrency-aware BDI agent architectures. The findings enable principled framework evaluation, informed customization, and targeted enhancement of concurrency support in intelligent agent systems.

This work addresses the challenges students face in understanding and debugging nondeterministic concurrency bugs—such as deadlocks and race conditions—when learning parallel programming. The authors propose ParaView, an educational tool that integrates execution trace visualization with large language model (LLM) analysis, uniquely combining program execution logs, visual representations of parallel behavior, and LLM-driven error explanations and repair suggestions for concurrent programming instruction. In an evaluation with 17 students, the use of ParaView led to significantly higher success rates in both debugging and implementation tasks. Most participants reported that ParaView effectively supported their learning, and the LLM accurately identified common concurrency errors and interpreted execution traces, though its repair suggestions remained limited in complex synchronization scenarios.