golang development

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.

Prior FFI research has predominantly focused on Python and Java, overlooking the unique characteristics and security implications of CGO—the C interoperability interface in Go. Method: This paper presents the first systematic empirical study of CGO usage and associated security risks in real-world open-source Go projects. Analyzing 920 projects, the authors identify that 11.3% enable CGO, categorize four core usage intents and fifteen typical patterns, and uncover 19 critical issue classes—including runtime-critical crashes induced by Go toolchain defects. They develop CGOAnalyzer, a tool integrating static analysis with large-scale empirical evaluation for automated detection and quantitative assessment. Contribution/Results: The proposed mitigation strategies have been adopted in practice, and related improvement proposals have been accepted into the official Go proposal process, significantly enhancing the reliability and security of Go programs in polyglot integration scenarios.

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.

General-purpose chat-based LLM interfaces (e.g., ChatGPT) lack usability features tailored for web application development, hindering end-to-end application construction by non-programmers. Method: We propose the first language model interface specifically designed for zero-code web application generation. It innovatively integrates structured input, real-time feedback, and user-story-driven task decomposition, combined with frontend visual design, prompt engineering optimization, and GPT-series models. Contribution/Results: In a user study with 14 novices, nine fully implemented all user stories and five completed over half—achieving significantly higher task completion rates than ChatGPT. The results empirically validate that our interface effectively lowers the programming barrier imposed by LLMs and enhances practical development usability for non-experts.

This work addresses the lack of effective automated testing mechanisms in microservice architectures, where existing API specifications such as OpenAPI suffer from limited semantic expressiveness and thus struggle to support high-coverage automated validation. To overcome this limitation, the authors propose APOSTL—an extension of OpenAPI grounded in restricted first-order logic—that enables formal annotation of semantic properties of APIs. Complementing this specification language, they develop PETIT, a tool that performs fully automated, source-code-free black-box testing using only APOSTL-annotated OpenAPI documents. By embedding formal logic directly into API specifications for the first time, this approach allows interface documentation to drive semantically precise and high-coverage automated tests, significantly enhancing the efficiency and reliability of microservice verification.

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.

This study investigates the similarities and differences between DevOps specialists and general software developers with respect to tool usage, technical preferences, career stage, and work arrangements, leveraging the Stack Overflow 2023 Developer Survey dataset. Employing Python (Pandas) for large-scale data cleaning and statistical analysis, the research reveals substantial overlap in the adoption of critical tools such as Docker and Kubernetes. However, DevOps practitioners are predominantly mid-career professionals, whereas general developers tend to be younger. Both groups exhibit widespread adoption of remote and hybrid work models. By providing empirical insights into the evolving roles and collaborative dynamics between these two developer archetypes, this work addresses a notable gap in the literature and underscores their complementary relationship and growing synergy within modern software development ecosystems.

This work addresses the challenges of IDE development posed by the rapid evolution of smart contract languages such as Move by presenting a high-performance IDE support system built atop the Move compiler and adhering to the Language Server Protocol (LSP). Through deep integration with existing language toolchains and the application of incremental parsing and optimized semantic analysis techniques, the system efficiently delivers rich IDE features even as the language undergoes continuous iteration. Deployed successfully within the Sui platform’s Move ecosystem, it significantly enhances developer experience and yields a reusable, evolution-aware IDE construction strategy applicable to other emerging programming language ecosystems.

This study addresses the critical issue of frequent failures in GitHub Actions workflows, which severely undermine automation reliability and maintainability. For the first time, it systematically maps 197 language constructs to 14 workflow capability features through a large-scale quantitative analysis of over 260,000 workflows across 49,000 repositories. By integrating language construct categorization with metadata mining, the work uncovers prevalent usage patterns, evolutionary trends, and their impact on workflow reliability. The findings reveal that only a small subset of constructs is heavily used, and that specific capability features are significantly associated with elevated failure rates and maintenance costs. These empirical insights provide actionable guidance for optimizing workflow design and improving robustness in continuous integration and delivery pipelines.

This study addresses the challenge that local deadlocks in Go programs are difficult to detect and lack automated repair mechanisms. To this end, this work proposes a fully automated approach encompassing both deadlock detection and repair. The method leverages a message-passing intermediate representation combined with symbolic analysis techniques to precisely identify both global and local deadlocks, and employs source code transformation algorithms to automatically generate repair patches. Experimental results demonstrate that the proposed tool achieves deadlock detection performance comparable to existing state-of-the-art tools. Furthermore, it realizes the first automated repair of local deadlocks, thereby filling a critical technical gap in this domain.