rpc protocol implementation

This study addresses the lack of systematic understanding regarding the implementation and maintenance of the Model Context Protocol (MCP) in real-world open-source projects. To bridge this gap, we introduce a transparent, reproducible multi-stage validation pipeline that integrates GitHub REST/GraphQL APIs with custom Python scripts to systematically annotate structural evidence, classify repository roles, and filter out non-functional examples from 3,238 candidate repositories. This process yields a high-quality dataset of 2,297 verified MCP projects, achieving a validation precision of 83% at 95% confidence. Our analysis reveals Python and TypeScript as the dominant implementation languages and identifies hybrid architecture as the most prevalent design pattern, thereby establishing the first large-scale empirical benchmark for MCP ecosystem research.

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.

Addressing the “oracle absence” and “error attribution difficulty” challenges in network protocol parser verification, this paper proposes an LLM-driven framework for RFC semantic parsing and feedback-based oracle refinement. First, large language models automatically translate unstructured RFC text into formal message specifications. Second, an iterative, quasi-oracle is constructed to support specification-guided fuzz testing and cross-language (C/Python/Go) protocol implementation verification. Finally, vulnerabilities are precisely traced back to their originating RFC clauses. This work is the first to integrate LLM-based semantic understanding with dynamic oracle refinement. Evaluated on nine mainstream protocols, it discovers 69 vulnerabilities—36 of which have been confirmed—surpassing state-of-the-art approaches in both effectiveness and efficiency. It also demonstrates, for the first time, the feasibility of fully automated derivation of test oracles directly from natural-language protocol specifications.

To address the error-prone and inefficient manual rewriting of data transformation logic upon JSON Schema evolution, this paper proposes a type-directed, top-down program synthesis approach for automatically generating semantics-preserving JSON Schema converters. Our method integrates type inference, semantic constraint modeling, a rewrite system, and intermediate representation (IR)-driven code generation to guarantee lossless data transformation and formal verifiability. It natively supports complex nested schemas and synthesizes correct, efficient, and human-readable Python and JavaScript conversion code. We evaluate our approach on real-world API configuration schemas and healthcare data integration scenarios, demonstrating its safety—via formal guarantees and empirical validation—its practical utility in industrial settings, and its generalizability across diverse schema evolution patterns. Experimental results confirm high accuracy, robustness to structural changes (e.g., field additions, type refinements, nested object restructuring), and scalability to large, deeply nested schemas.

Software engineers face significant challenges—including difficulty in modeling, lengthy prototyping cycles, and high verification costs—when developing control algorithms for complex dynamic systems such as communication networks. To address these issues, we propose GIPS, the first model-driven engineering framework that tightly integrates graph-structured integer linear programming (ILP) modeling with automated code generation. Using the domain-specific language GIPSL, users declaratively specify constraints and optimization objectives; GIPS then automatically generates functionally complete, executable Java graph-optimization components. This enables end-to-end rapid prototyping—from high-level specifications to runtime deployment. We validate GIPS on a tree-structured peer-to-peer topology control scenario, demonstrating its correctness, efficiency, and scalability. The full implementation—including source code and a ready-to-run virtual machine demonstration environment—is open-sourced, confirming its practical deployability and engineering utility.

本文通过将Paxos协议的伪代码转化为可执行的DistAlgo语言，解决了分布式系统中复制与共识协议的理解和验证问题。

This study addresses the lack of standardized practices in Model Context Protocol (MCP) regarding configuration, communication, and human oversight, noting that prior research has predominantly focused on server-side implementations while neglecting application-level usage. To bridge this gap, we introduce MCPAppTax, the first taxonomy for MCP applications, and conduct a large-scale empirical analysis of 1,723 MCP applications on GitHub, leveraging large language model–assisted annotation and static code analysis. Our findings reveal both convergent practices—such as 85.2% adopting file-based configuration and 81.1% using official SDKs—and divergent ones, notably the absence of standardized naming conventions for configuration parameters. Furthermore, while human supervision mechanisms are prevalent (90.8% log interactions and 77.2% offer start/stop controls), only 37.2% implement blocking-style human approval, highlighting significant variability in safety-critical oversight.

本文提出一种统一的消息模型，用于描述异构串行数据交换协议，并通过工业工具环境实现，支持自动化开发和标准化及弱形式化串行协议的工程应用。

本文使用依赖类型解决分布式系统中协议实现的复杂性问题，通过在Lean语言中实现编舞库，确保端点投影和值访问的安全与完整。

This study addresses the cumbersome nature of Python coroutine pipelines and the ambiguous specifications of JavaScript push-stream protocols by proposing a producer-driven streaming protocol based on formal refinement. Methodologically, the TLA+ specification language and the TLC model checker are employed to ensure design correctness through stepwise refinement verification. The proposed protocol seamlessly integrates synchronous and asynchronous modules, achieving unbounded buffered flow control and graceful termination. Furthermore, it supports independent termination of intermediate modules with explicit reporting of environmental suspension states, thereby avoiding error recovery mechanisms and eliminating the need for dynamic heap allocation. Experimental results demonstrate that the protocol’s critical properties fully satisfy the formal specification. It can express a superset of JavaScript streaming semantics and significantly outperforms existing Python-based solutions.