develop backend services

This paper addresses critical challenges in e-commerce frontends—tight coupling, outdated technologies, and poor developer experience—by empirically investigating the applicability boundaries of micro-frontend architecture. Method: Using a handcraft e-commerce platform as a case study, we incrementally decompose the monolith via an API gateway and Backend-for-Frontend (BFF) pattern, then implement Svelte-based micro-frontends atop an existing microservices infrastructure to achieve frontend-backend decoupling and team-autonomous delivery. Contributions: First, we systematically validate—within a real-world e-commerce setting—the necessity and inherent limitations of micro-frontends. Second, we demonstrate that leveraging an established microservice ecosystem significantly lowers adoption barriers. Third, we empirically show that micro-frontends are not universally superior: a well-architected monolithic frontend remains viable for equivalent functional goals, underscoring that architectural decisions must align closely with organizational capabilities and evolutionary maturity. Survey-based evaluation confirms measurable improvements but reinforces the principle of “context-sensitive” architecture selection.

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.

To address core challenges in microservice architecture—including operational complexity, high inter-service communication overhead, and difficulty ensuring data consistency—this paper proposes a microkernel-based architectural paradigm tailored for Web systems. The design centers on a lightweight kernel that serves as an integration hub, enabling dynamic loading and unloading of service modules via contract-driven plugin mechanisms. Innovatively, we introduce a cloud-native–enabled, lightweight MAPE-K (Monitor-Analyze-Plan-Execute over a shared Knowledge base) adaptive control framework to enhance self-healing and self-optimization capabilities. Compared with conventional microservices, the proposed architecture reduces cross-service invocation overhead by over 35%, accelerates fault recovery by 2.1×, and supports hot-pluggable extension and dynamic policy updates. It thus reconciles the simplicity of monolithic architectures with the elasticity of microservices, offering a novel intermediate architectural option for medium-to-large-scale Web systems.

This work addresses the challenges in edge and embedded application development—namely, heterogeneous software stacks, multi-language runtimes, and difficult debugging—which lead to rigid deployment workflows and complex fault diagnosis. To overcome these limitations, the paper proposes a novel architecture enabling unified end-edge-cloud development. Its core components include a single programming language, a retargetable runtime system, a local recording and replay mechanism for distributed events, and a cross-platform deployment framework. This design breaks down traditional debugging barriers in edge–cloud collaborative development, facilitating seamless scalability, consistent testing, and flexible deployment across heterogeneous environments. Evaluation of the prototype system demonstrates that the proposed approach significantly simplifies deployment procedures and enhances fault diagnosis efficiency.

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 the limited understanding of how practitioners actually develop software engineering (SE) agents, particularly the lack of systematic investigation into the evolution of development workflows and core challenges. Through semi-structured interviews with 20 practitioners complemented by a survey of 80 respondents, this work proposes the first seven-stage workflow for SE agent development, revealing a paradigm shift toward “evaluation-driven iteration.” The research identifies that bottlenecks have moved beyond coding to non-coding tasks such as requirement specification, cross-role coordination, review, and deployment. It systematically characterizes six key challenges—including unreliable evaluation signals, accumulating comprehension debt, and behavioral drift induced by model updates—and synthesizes corresponding practical mitigation strategies.

研究了跨生态系统软件包的普遍性、架构模式及其与项目健康度的关系，通过分析六大生态系统中的六百万个软件包，识别出五种架构模式。

This study addresses the lack of empirical evidence regarding performance disparities between microservice and monolithic architectures in e-commerce scenarios. Utilizing k6, we conducted quantitative load testing on both architectural paradigms sharing identical application logic and database backends. Experimental results demonstrate that under a 100-concurrent-user workload, the microservice architecture achieves a 5.4% increase in throughput and a 39% reduction in p95 tail latency, alongside lower error rates and superior fault isolation. These findings bridge the empirical gap in runtime performance comparison, validating the scalability advantages and specific failure modes of microservices under high load. Consequently, this research provides a reliable quantitative basis for informed architectural decision-making in e-commerce systems.

This work addresses logical redundancy, state fragmentation, and poor maintainability arising from front-end/back-end heterogeneity in AI-generated web applications by proposing a backend-driven hypermedia application model. The approach uniquely integrates Kotlin’s statically typed HTML DSL with a reactive signal mechanism, enabling automatic synchronization between UI and backend state through type-safe custom HTML attributes and builder patterns, thereby substantially reducing reliance on JavaScript. Built upon HtmlFlow extensions, Datastar data attributes, and the Spring MVC architecture, the method demonstrates in the Petclinic case study a near-complete elimination of client-side scripting, enhanced type safety, and the realization of an isomorphic reactive interaction paradigm across frontend and backend.

This study addresses the infrastructure complexity of cloud-edge-end协同 architectures, which has emerged as a major bottleneck hindering developer productivity and innovation. Through 101 semi-structured interviews across 86 organizations, this work empirically identifies deployment complexity and onboarding difficulty as core challenges. It proposes four architectural directions to mitigate these issues: Object-as-a-Service (unified object abstraction), internal developer platforms, declarative AI/ML pipelines, and lightweight edge runtimes. Findings indicate that high-level abstractions and automation significantly enhance developer experience—outweighing the impact of execution performance optimizations—and thereby establish a new paradigm for platform engineering and distributed system design.