web services development and operations

To address performance overhead escalation and transaction boundary degradation arising from process decomposition during monolith-to-microservices migration, this paper proposes a lightweight, trace-based what-if analysis method. The approach comprises three stages: execution trace collection and rewriting, performance-sensitive call-chain simulation, and abstract modeling of transaction boundaries—enabling rapid, quantitative assessment of non-functional property changes induced by service decomposition alternatives. Its core innovation lies in introducing the first trace-rewriting analysis paradigm prioritizing usability and speed, requiring neither source-code modification nor deployment in production-like environments. Evaluated on industrial case studies, the method completes each scenario assessment in seconds—achieving two orders-of-magnitude improvement in analysis efficiency—and thereby significantly facilitates high-frequency, low-friction iteration over service boundaries and informed trade-off decisions.

This study addresses the inefficiency in serverless platforms caused by complex, non-conservative information flows among functions. It introduces Hodge decomposition—a novel application in this domain—to construct a service topology model that decomposes observed operational flows into locally correctable components and globally persistent harmonic modes. The work demonstrates that harmonic flows are intrinsic structural characteristics of the system rather than artifacts of misconfiguration, and leverages this insight to propose new optimization mechanisms such as the “dumping effect.” By constructing service flow spectra and performing harmonic analysis, the approach effectively identifies architectural-level performance bottlenecks, thereby validating its efficacy in uncovering structural inefficiencies and guiding targeted performance optimizations.

This work addresses the challenge of effectively evaluating the trade-offs between data consistency and coordination overhead among distributed transaction patterns—such as Saga and TCC—in business logic-intensive microservice systems prior to production deployment. The authors propose a lightweight microservice simulator grounded in Domain-Driven Design (DDD), which, for the first time, integrates DDD aggregate root modeling with multiple transaction models to decouple business logic from communication and transactional infrastructure. The framework supports configurable deployment topologies and network constraints, enabling seamless transitions from centralized to fully distributed architectures while providing a deterministic verification environment. Empirical evaluation on complex multi-aggregate systems quantifies the performance, coordination overhead, and resilience of different transaction models, substantially reducing development costs and facilitating left-shifted architectural validation.

This work addresses the low development efficiency and high maintenance overhead associated with manual implementation of RESTful microservices. We propose an API-first, LLM-powered automated code generation method that takes OpenAPI specifications as input and produces executable microservices via a novel LLM-driven generation framework. Crucially, we introduce— for the first time—a runtime log analysis and error feedback mechanism, enabling a closed-loop optimization paradigm: “specify → generate → execute → debug → refine.” Compared to conventional development practices, our approach significantly accelerates prototyping and reduces manual iteration cycles. Empirical evaluation with six industry practitioners demonstrates substantial improvements in coding automation and rapid experimentation capabilities. The method establishes a new pathway toward API-driven, intelligent software engineering.

Microservice system developers lack empirical evidence regarding the types, root causes, and remediation strategies of recurring issues. Method: We adopt a mixed-methods approach—quantitatively analyzing 2,641 open-source issues, qualitatively interviewing 15 practitioners, and conducting a global survey with 150 practitioners. Contribution/Results: We introduce the first comprehensive, domain-specific three-level taxonomy (“Issue–Cause–Solution”) for microservices. We identify five high-frequency issue domains—including technical debt, CI/CD pipeline failures, and exception handling—and three predominant root causes, notably generic programming errors. From our analysis, we distill 177 actionable, context-aware remediation strategies. This work establishes an empirical foundation for microservice fault diagnosis and mitigation, delivers practical guidance for industry practitioners, and pinpoints critical research directions for next-generation microservice engineering.

This study addresses a critical gap in the literature by shifting focus from structural aspects of microservice architectures to the role of developers in shaping organizational coupling (OC). Through longitudinal mining of GitHub repositories—including commits, issues, and pull requests—the authors identify three key developer roles: Jacks, Mavens, and Connectors. They quantify each role’s contribution to OC and its evolutionary dynamics, revealing for the first time that OC is fundamentally a role-driven phenomenon. Specifically, Connectors significantly intensify global coupling, whereas Jacks and Mavens exert more localized effects. Moreover, the co-occurrence of multiple roles amplifies coupling effects. These findings offer a novel, role-aware perspective for designing organizational structures in microservice ecosystems.

This study addresses the lack of systematic guidance for enterprise software teams in choosing between monolithic and microservices architectures. The work proposes a decision-making framework that integrates technical and organizational factors, evaluating the trade-offs of each architecture across dimensions such as scalability, reliability, deployment efficiency, and organizational complexity. The assessment is grounded in system scale, business requirements, operational maturity, and long-term maintainability. Through architectural pattern analysis, a structured evaluation model, and multiple case studies, the authors develop a practical selection methodology tailored to real-world engineering contexts. This approach offers enterprises clear architectural evolution pathways and actionable guidelines aligned with their developmental stages, thereby significantly enhancing the rationality and sustainability of system design decisions.

While large language models (LLMs) can generate executable multi-service application environments, they often deviate from the architectural and security requirements essential for production deployment. This work proposes a method to automatically generate Dockerfiles and Docker Compose configurations solely from code repositories, evaluating deployment fidelity through end-to-end HTTP testing and structural comparison. It explicitly distinguishes between functional correctness and fidelity to deployment intent, deriving a minimal set of explicit deployment specifications that cannot be inferred automatically from source code alone. Experiments successfully reproduce the topology and dependencies of three heterogeneous multi-service systems, confirming functional feasibility; however, critical production-grade features—such as network isolation and multi-stage builds—are consistently absent, revealing fundamental limitations in current LLMs’ ability to model deployment intent.

针对微服务架构中跨服务边界的代码克隆问题，开发了CC4M工具，通过检测和可视化手段辅助分析克隆代码的影响范围及维护成本。

This work addresses the challenges of resource utilization and operational efficiency in microservice architectures by proposing a performance-metric-driven automated framework that intelligently determines the optimal deployment strategy for individual microservices between Infrastructure-as-a-Service (IaaS) and Function-as-a-Service (FaaS). By analyzing intrinsic microservice characteristics, the framework enables a scalable and reproducible migration from conventional IaaS deployments to a hybrid IaaS+FaaS model. Experimental evaluation on two real-world applications demonstrates that the approach accurately identifies microservices well-suited for serverless execution, significantly improving both deployment efficiency and resource utilization. Furthermore, the study clarifies the respective applicability boundaries and advantages of different cloud service models, offering practical guidance for architecture design in heterogeneous cloud environments.