The article explains how the vtprotobuf library writes to a byte slice from the tail toward the head, eliminating bounds‑check instructions, and demonstrates this effect with simple functions, compiler diagnostics, and references to the Go compiler source.
Using protobuf‑generated .pb.go structs directly in Go business code introduces zero‑value ambiguities, naming mismatches, and loss of encapsulation, leading to bugs and technical debt; the article explains these pitfalls with concrete examples and shows how to keep protobuf at the transport layer while mapping to clean domain models.
A researcher discovered an unauthenticated debug endpoint in Google Cloud that leaked protobuf definitions, turned it into a "req2proto as a Service", abused Stubby RPC permissions, chained several API calls to achieve full remote code execution, and received a $148,337 bug‑bounty.
This article explains why traditional Java UI toolkits fall short, then walks through a complete solution that embeds a React + shadcn/ui front‑end inside a Java desktop window using JxBrowser, covering window creation, resource loading for dev and production, and two Java‑Web communication strategies (JS‑Java bridge and Protobuf + gRPC).
This article explains how to embed modern web UI built with React, TypeScript, and shadcn/ui into a Java desktop application using JxBrowser, covering reliable web view integration, server‑less resource loading, and bidirectional Java‑JavaScript communication via bridges or gRPC.
The article walks through Gin 1.12's new features—including native BSON handling for MongoDB, type‑safe context error methods, custom binding for dates and enums, raw‑path routing, colored latency logs, and automatic Protobuf/JSON negotiation—showing practical code examples and upgrade recommendations for microservice development.
Gin 1.12 introduces BSON support for direct MongoDB responses, enhanced context error handling, flexible custom binding, raw‑path routing, colored latency logs, and automatic Protobuf/JSON content negotiation, all demonstrated with practical Go code examples and performance tables.
This guide walks you through building a production‑grade e‑commerce order service using the Go‑based Kratos microservice framework, covering environment setup, protobuf contract definition, code generation, layered architecture, dependency injection, configuration, deployment, testing, and performance optimizations for cloud‑native backends.
This step‑by‑step guide shows how to use the Go‑Kratos microservice framework to create a clean‑architecture user service, covering environment setup, project scaffolding, Protobuf API definition, code generation, layered implementation (biz, data, service), server registration, and testing with curl.
The article explains how the traditional protoc‑based Go protobuf workflow suffers from environment hell, path nightmares, and lack of linting, and demonstrates step‑by‑step how Buf CLI—combined with its built‑in lint, breaking‑change detection, and optional Schema Registry—replaces protoc with a declarative, reproducible, and cloud‑native toolchain.
This article walks through a complete performance upgrade of a Go microservice by defining protobuf contracts, generating gRPC code, running both HTTP and gRPC servers side‑by‑side, and using gRPC‑Gateway to keep REST compatibility, resulting in lower latency and a future‑ready architecture.
This tutorial walks through creating a Go‑based internal file transfer service from scratch, covering custom frame protocol design, Protobuf command handling, zero‑copy sendfile, chunked read/write with resume support, CRC32 integrity checks, and performance‑tuning techniques.
This article dissects the hidden technical debt of internal HTTP APIs, explains why HTTP/1.1 causes head‑of‑line blocking, redundant headers and serialization overhead, and walks through a step‑by‑step, data‑driven optimization roadmap—including HTTP/2, Protobuf, request aggregation, connection pooling, compression, caching, async processing, observability, and safe gray‑release deployment—backed by concrete benchmarks and code samples.
The article explains why JSON can become a performance bottleneck in high‑throughput APIs and compares four binary serialization formats—Protocol Buffers, FlatBuffers, MessagePack, and CBOR—showing benchmark results, trade‑offs, and a practical migration checklist.
This article explains why architecture‑level contract decisions are needed in distributed systems, compares strict and loose data contracts, illustrates schema‑on‑read/write patterns, and shows how to ensure forward and backward compatibility when evolving protocols such as JSON and Protobuf.
This guide explains how pbgo extends Protobuf to automatically generate lightweight REST handlers for Go gRPC services and shows how to use the pure‑Go tool grpcurl for fast, code‑free debugging, complete with installation steps, command examples, and practical recommendations.
Learn how to create a high‑performance Go microservice using gRPC and Protocol Buffers, covering gRPC advantages, Protobuf service definitions, step‑by‑step server and client implementation, performance comparison with REST, and an introduction to streaming communication modes.
Java serialization, while convenient for persisting objects, suffers from versioning issues, hidden fields, mutable data snapshots, performance overhead, security vulnerabilities, singleton breaches, final field tampering, external dependencies, maintenance burdens, and format limitations, and the article recommends explicit serialVersionUID, custom methods, and JSON/Protobuf alternatives.
This article explains Google Protocol Buffers' binary serialization, covering its advantages and drawbacks, the encoding mechanisms of tags, varints, ZigZag, embedded and repeated fields, and provides practical best‑practice guidelines for designing robust .proto schemas.
The article outlines seven practical performance‑optimization techniques for high‑throughput back‑ends—including replacing protobuf with native C++ classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc, implementing lock‑free double buffers, simplifying structs for specific scenarios, and leveraging profiling tools—while stressing balanced, incremental improvements.
Serialization in C++ bridges in‑memory objects and persistent or network formats, addressing challenges like byte order, data type compatibility, and complex structures, while the article reviews core principles, binary and text formats, major libraries such as Protobuf, Cereal, Cista++, ThorsSerializer, and offers guidance on selecting and using them effectively.
The article explains how Protocol Buffers (proto3) encode basic and composite types using varint, zigzag, fixed-size and IEEE‑754 formats, describes tag and length field structures, and presents optimization strategies such as selecting size‑efficient types, flattening nested messages, and delta‑encoding to significantly reduce serialized byte‑stream size.
gRPC offers high performance for microservices, but its generated protobuf code, required fields handling, and steep learning curve create ugly, hard‑to‑maintain implementations; this article examines those pain points, showcases examples, and suggests tools and best practices to mitigate them.
The article outlines Bilibili’s revamped recommendation data‑flow architecture that eliminates timing and calculation inconsistencies by snapshotting online features, unifying feature computation in a single C++ library accessed via JNI, and orchestrating label‑join and sample extraction through near‑line Kafka/Flink pipelines, with further performance gains and Iceberg‑based future extensions.
gRPC can halve request latency compared to REST+JSON by leveraging HTTP/2’s multiplexed connections and the compact binary Protobuf format, which reduces payload size and speeds serialization, though it introduces complexities like load balancing, debugging, and contract management.
The article explains serialization and deserialization fundamentals, highlights pitfalls such as ambiguous binary streams and platform‑dependent field sizes, then compares Java’s native ObjectOutputStream, JSON libraries, Hessian binary RPC, and Google’s Protobuf, guiding readers to select the appropriate format based on performance, payload size, and type‑safety needs.
The article highlights how fragmented, undocumented cross‑team communication creates fragile software, then advocates adopting contract‑based design—preconditions, postconditions, invariants—and AI‑assisted tooling to formalize API contracts throughout the development lifecycle, aligning teams, reducing errors, and improving system reliability.
This article walks frontend developers through the fundamentals of the TRPC framework, explaining why understanding RPC protocols, the layered architecture, plugin system, multi‑process handling, and Protobuf serialization is essential for building high‑performance, scalable services and improving debugging efficiency.
This article explores a hands‑on AI4SE prototype that leverages ArchGuard, Team AI, and Shire AI to digitize and automate architecture knowledge across the full SDLC of a Protobuf‑driven microservices system, detailing challenges, methods, and concrete tool integrations.
An Nginx‑based data collection gateway began crashing with OOM kills, prompting a detailed investigation that uncovered memory spikes caused by aggressive batch processing, oversized protobuf payloads, and insufficient memory‑pool management, leading to a custom core‑dump solution and several mitigation strategies.
Bilibili transformed its search indexing pipeline by replacing a manual, low‑throughput process with a distributed KV store (Taishan) and Spark‑based construction, achieving unified data ingestion, reduced resource consumption, faster full‑ and incremental builds, and a shift from daily to hourly indexing cycles.
This article details Bilibili's transformation of its search offline indexing architecture—from a manual, low‑throughput MySQL‑centric process to a distributed, KV‑based, protobuf‑driven pipeline that leverages Taishan storage and Spark, cutting build cycles from days to hours while solving performance, consistency, and maintenance challenges.
This article explains five common serialization techniques—Java native serialization, Hessian, JSON, Google Protobuf, and Kryo—detailing their principles, performance characteristics, code examples, and when to choose each for Java backend systems.
This article details Bilibili's transformation of its search offline indexing pipeline, moving from manual MySQL‑based processes to a high‑capacity, distributed KV store and Spark‑driven builds, addressing performance, maintenance, and scalability challenges while improving resource efficiency and iteration speed.
This guide walks you through what Protocol Buffers are, how to install the protoc compiler on macOS, Windows, and Python, explains the proto3 syntax—including messages, fields, enums—and demonstrates compiling .proto files and using the generated code in Python, while highlighting Protobuf's efficiency, extensibility, and multi‑language support.
The article presents practical backend performance optimization methods—including substituting Protobuf with native C++ classes, employing cache‑friendly data structures, integrating jemalloc/tcmalloc, using lock‑free double‑buffer designs, and tailoring data formats—to achieve up to three‑fold speed improvements and significant latency reductions.
This article introduces TypeSpec, a lightweight, extensible language for describing REST, OpenAPI, gRPC and other APIs, outlines its key features, demonstrates how to generate OpenAPI, JSON Schema and Protobuf files, and provides step‑by‑step instructions for installing the compiler, setting up the VS Code extension, creating a project, and compiling a sample service.
This article walks through a series‑by‑step performance‑tuning process for high‑throughput C++ services, replacing Protobuf with plain classes, adopting cache‑friendly hash tables, switching to jemalloc, implementing a double‑buffer lock‑free data structure, and tailoring data formats, each backed by concrete code examples, benchmark results, and analysis of trade‑offs.
This article presents practical performance‑optimization strategies for high‑throughput C++ services, including replacing Protobuf with hand‑written classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc instead of the default allocator, employing lock‑free double‑buffer designs, tailoring data formats for specific workloads, and leveraging profiling tools to measure gains.
The article outlines practical, continuous performance‑optimization tactics for high‑throughput back‑end services—replacing Protobuf with lightweight C++ classes, using cache‑friendly data structures, adopting jemalloc/tcmalloc, employing lock‑free double buffers, tailoring data formats, and leveraging profiling tools—to achieve multi‑fold speedups while balancing maintainability.
This article describes the motivation, design, and usage of Hasaki, a lightweight Go HTTP Restful client that supports custom status‑code handling, multiple data formats such as JSON, XML, YAML and protobuf, builder‑style chaining, and extensible middleware, providing code examples and a plugin architecture.
This article dissects the end‑to‑end technical workflow of sending a customer‑service IM message, covering reliability, real‑time delivery, ordering, idempotency, performance bottlenecks, async handling, requestAnimationFrame, protobuf migration, and user‑experience optimizations, while sharing concrete metrics and real‑world solutions.
The Bilibili video template system combines theme‑based editing, a layered architecture, and a cross‑platform Protobuf protocol to enable PGC and UGC creators to produce, review, distribute, and consume richly‑featured videos with standardized media formats, modular plugins, AI integration, and robust quality assurance.
The article examines the end‑to‑end technical and design challenges of delivering a single customer‑service instant‑message, detailing reliability, ordering, idempotency, performance optimizations such as async handling and binary‑search traversal, security practices, latency reductions via Protocol Buffers, and a roadmap for future enhancements.
This article shares Tubi’s experience using Elixir‑gRPC in production, covering performance optimizations, stability measures, HTTP/2 edge‑case handling, and practical code examples for efficient Protobuf processing; it also discusses Envoy sidecar integration, interceptor usage, and lessons learned from real‑world deployments.
This article explains the principles behind IL2CPP memory parsing, demonstrates how to use exported Unity functions via Frida to retrieve assemblies, classes, and methods, and shows techniques for identifying protobuf messages and handling version differences and anti‑tamper protections.
The Shopee Games team created a custom Protobuf‑driven API gateway that unifies external HTTP and internal RPC traffic, automatically generates routing, authentication, logging and Swagger from proto annotations, shares capacity across services, and boosts performance and resource utilization for their micro‑service‑based casual gaming platform.
This article details how Ctrip's hotel team used Flutter to improve app performance over two years by monitoring FPS, TTI, memory, applying widget‑tree optimizations, lazy loading, frame rendering, service‑channel enhancements with Protobuf, and systematic memory‑leak detection and mitigation.
Music FeatureBox is NetEase Cloud Music’s custom feature store that centralizes metadata, unifies offline and online feature storage across multiple engines, provides a cross‑language DSL for extraction, ensures training‑inference data consistency, and offers built‑in monitoring, thereby streamlining feature engineering and accelerating the platform’s machine‑learning lifecycle.
This article details the evolution of caching architecture from XML-based caching to a multi-level caching system using Protobuf and LocalCache, achieving 70% improvement in API response times.
This article explains how to unify error handling between gRPC and traditional HTTP services by defining shared protobuf messages, mapping gRPC status codes to HTTP responses, and customizing response structures with additional fields like stat and msg for consistent business‑level error reporting.
This article walks through setting up the Go environment, defining protobuf files, generating code, and implementing both server and client sides of a gRPC service, complete with runnable examples, common pitfalls, and output verification to help developers quickly adopt Go‑based gRPC testing.
This article explains how to engineer APIs by automating protobuf file management, code generation, CI/CD pipelines, error handling, validation, and documentation generation using tools such as GitLab, Kratos, Apifox, and quicktype, ultimately improving development efficiency across backend and client teams.
This article presents a comprehensive overview of Baidu's short‑video Push system, detailing its architecture, core modules, data flows, and successive optimizations such as personalized send‑time estimation, user‑group management, frequency‑control redesign, and protobuf compression, illustrating how these improvements enhance scalability, reliability, and resource efficiency.
Baidu’s Short Video Push System is a distributed platform serving hundreds of millions of users across multiple apps, delivering personalized, real‑time notifications via a modular architecture that includes material and user centers, recall, preprocessing, and delivery services, while optimizations such as activity‑based scheduling, bitmap‑based user segmentation, consistent‑hash frequency control, and protobuf compression boost click‑through rates, scalability, and resource efficiency.
The article presents a Guard abstraction that temporarily borrows and returns Protobuf field pointers via set_allocated/release, eliminating costly CopyFrom operations in recommendation pipelines, enabling zero‑copy field sharing across central‑control and recall stages, improving CPU usage and latency while handling safety and rollback.
The article explains gRPC fundamentals, illustrating service definition in .proto files, synchronous and asynchronous client and server implementations with CompletionQueue and CallData state machines, streaming RPC patterns, HTTP/2 protocol details, metadata handling, and the structure of generated stub and service code.
The article examines Java's built‑in Serializable interface, highlights its cross‑language incompatibility, large payload size, and low efficiency, then presents benchmark code comparing it with a custom binary encoding, showing significant reductions in data size and processing time, and recommends modern frameworks such as Protobuf or Thrift.
This tutorial explains what Protocol Buffers are, why they outperform JSON/XML, and provides a step‑by‑step guide for installing the compiler, defining .proto schemas, generating Java code, integrating with Maven, and using protobuf for fast serialization in micro‑service RPC.
This article introduces the lightweight Go microservice framework Kratos, covering its Protobuf‑driven API design, open and extensible architecture, logging and tracing integrations, functional‑option configuration, unified error model, and compile‑time dependency injection with code examples and diagrams.
This article explains a Scala‑based DSL that uses macros and implicit parameters to generate type‑safe, boiler‑plate‑free conversion code between protobuf‑java messages and Scala case classes, showing examples, builder customisation, and upcoming Scala 3 support.
The article explains what object serialization is, why it is needed for persistence and network transmission, outlines the major drawbacks of Java's built‑in serialization—including lack of cross‑language support, poor performance, and large payloads—and compares it with a custom ByteBuffer approach while reviewing popular alternative serialization frameworks.
This article explores Baidu C++ engineers' deep‑dive into performance optimization, covering memory‑access patterns, string‑buffer handling, protobuf merging, malloc strategies, job‑arena allocation, cache‑line effects, and modern memory‑order semantics to achieve multi‑fold speedups in large‑scale backend services.
The article analyzes the core technical challenges of mobile instant‑messaging services—battery consumption, limited traffic, unreliable networks—and explains how WeChat and Momo design hybrid short‑/long‑connection protocols, use protobuf, intelligent routing, load‑balancing, sharding and distributed algorithms to achieve high reliability and scalability.
The article explains how Dubbo can use the Protostuff library as a drop‑in replacement for .proto files to perform Protobuf TLV serialization, detailing the wire‑type encoding, Maven setup, POJO example, byte‑level analysis, Dubbo configuration, and tips for reducing serialization overhead.
This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.
To overcome aging hardware and code limitations, QQ Mail rebuilt its full‑text search using Tencent Cloud Elasticsearch, adding an esproxy layer, MQ‑driven updates, HTML‑to‑text extraction, protobuf‑JSON conversion, index sorting, two‑stage precise/fuzzy queries, and custom tokenizers, delivering scalable, low‑latency email search.
MongoDB’s flexible, schema‑less design offers performance benefits but can become a maintenance nightmare as projects grow, so the article explains why introducing external schema protocols like Google’s Protobuf or Facebook’s Thrift provides structure, reduces bugs, and balances flexibility with robustness.
This article demonstrates how to combine Spring Boot and Netty, define a .proto file, generate Java classes with protoc, configure Maven dependencies, and implement both server and client handlers to exchange binary Protobuf messages with heartbeat and reconnection logic.
The HotKey middleware, built on JD’s 618 stable version 0.2, introduces protobuf serialization and optimizes data transmission, achieving up to 37 k QPS stable throughput, 15% lower CPU peaks, and millisecond‑level hot‑key detection and push across dozens of core JD services, dramatically reducing backend storage load.
This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.
This article introduces Protocol Buffers, explains its advantages over XML, and provides a step‑by‑step guide for defining .proto files, compiling them with protoc, configuring a Java Gradle project, and writing code to serialize and deserialize objects using the generated classes.
This guide explains what Protocol Buffers are, compares them with XML, shows how to define a .proto schema, compile it with protoc, add the generated classes to a Java Gradle project, and demonstrates object serialization and deserialization with concrete code examples.
This article walks through integrating Spring Boot with Netty and using Google Protobuf for binary data exchange, covering Protobuf basics, Maven setup, code generation, server and client implementations, heartbeat handling, reconnection logic, and testing results, all with complete Java examples.
This article introduces Google’s Protocol Buffers (ProtoBuf), explains its principles, shows how to install the compiler, provides a complete Java example for defining, compiling, and using .proto files, and compares its encoding speed and memory usage against JSON, highlighting ProtoBuf’s advantages.
This article explains the product features, technical challenges, technology choices, and detailed architecture design for a live‑streaming quiz application that must support up to one million concurrent users, high QPS, low latency, and secure financial transactions.
This article explains the concept of object serialization, compares generic formats like JSON/XML with binary approaches, discusses optimization principles, key performance metrics, and reviews major serialization frameworks such as Protobuf, Thrift, Hessian, Kryo, and Avro, while also covering TLV encoding, varint algorithms, and practical pitfalls.
This article provides a comprehensive beginner-friendly guide to gRPC, covering its definition, the protobuf syntax for defining messages and services, field constraints, supported data types, usage of the protoc tool, and complete Go examples for both server and client implementations.
The Apache Dubbo 2.7.5 release introduces application‑level service registration, native HTTP/2 (gRPC) and Protobuf support, a 30% performance uplift, TLS security, an optimized consumer thread‑pool, a new Bootstrap API, multi‑registry load balancing, and numerous other enhancements aimed at cloud‑native microservice development.
This article outlines essential API design principles and best practices, covering simple, understandable, consistent, stable, and secure APIs, then delves into RPC mechanisms, Protobuf serialization, RESTful conventions, Swagger documentation, Spring Boot integration, HTTP/2 performance improvements, and the powerful combination of HTTP/2 with Protobuf in gRPC.
This article examines the challenges of high‑traffic live‑streaming instant messaging, presents the original V1 TCP‑based architecture, explains its performance bottlenecks, and details the redesigned V2 solution that adopts Netty, protobuf, compression, and RPC to dramatically reduce bandwidth and latency while supporting millions of concurrent users.
Gaode’s map platform serializes massive geographic data by weighing bandwidth, extensibility, and decoding speed, comparing open‑source protobuf and FlatBuffers with a bespoke binary format that adds chapter‑based storage, variable attributes, and aggressive compression, ultimately selecting the method that best fits specific size‑or‑speed priorities.
This article presents a comprehensive overview of Huajiao's gRPC development practice, covering background decisions, gRPC features, gateway integration, Dart and Go client libraries, component architecture, protobuf conventions, code generation, SDK integration, documentation tooling, debugging strategies, and future roadmap.
This article explains how to identify oversized JavaScript bundles with webpack‑bundle‑analyzer, split protobuf‑generated code into business‑specific modules, and apply Babel’s parser, traverse, types, and generator tools to automatically remove redundant commons code and restructure module patterns, dramatically reducing bundle size and improving frontend performance.
This article provides a step‑by‑step guide on installing the Protobuf compiler, setting up the Go plugin, writing .proto definitions, generating Go code, and demonstrating serialization and deserialization of Protobuf messages in a Go application, complete with troubleshooting tips and reference links.
The article outlines a comprehensive automated testing framework for a DSP advertising platform, covering income, interface, and log layers, and detailing the use of protobuf, Pytest, Logstash, ElasticSearch, Jenkins, and Allure to achieve efficient, real‑time quality assurance and continuous integration.
The article examines the advantages and drawbacks of microservices versus monolithic architectures, outlines key factors that influence the decision to split, and walks through a real‑world shared‑points project, detailing a four‑step process for decomposing a monolith into independent services.
By walking through the creation of a custom Android Studio (IntelliJ) plugin that reads protobuf files and auto‑generates Service and Presenter classes, the author shows how VFS, PSI, and project‑model APIs can replace tedious manual coding, delivering roughly 5.5% time savings per requirement.
MMKV is a high‑performance, mmap‑based key‑value component that uses protobuf for serialization, offering fast writes, incremental updates, space management, and data integrity checks, making it a superior alternative to NSUserDefaults for iOS applications.
This article details the architecture and key technologies of JD’s open platform, including a high‑performance API gateway, unified metadata configuration, TCP full‑duplex long‑connection channels, Protobuf data exchange, multi‑dimensional flow control, and a reliable message‑push system designed for massive 618‑scale traffic.
This article details the end‑to‑end process of designing and deploying an operations‑focused monitoring framework, covering semantic, log, and performance monitoring, protobuf integration, implementation challenges, actual effects, and future optimization directions for large‑scale online services.
This article presents a comprehensive Java benchmark that compares JSON libraries (Jackson, Fastjson, DSL‑JSON, Jsoniter, Thrift) with Google Protocol Buffers across various data types and structures, revealing where Protobuf truly outperforms JSON and where modern JSON parsers narrow the gap.
This article describes the design, implementation, and deployment of a custom Hadoop security solution that introduces username‑password authentication via RPC, integrates a new protobuf protocol, modifies NameNode behavior, and provides rollout tools to secure a large‑scale shared Hadoop cluster without service interruption.
This tutorial explains how to set up protobuf and gRPC, generate code from .proto files, and create a simple Python client (wrapped with Flask) to query relay information for live cloud streaming services, providing a lightweight alternative to manual log inspection.
This article benchmarks Java JSON libraries against Google Protobuf, analyzing decode/encode performance for integers, doubles, strings, objects, and lists, revealing that while Protobuf often outperforms JSON, optimized JSON libraries like DSL‑JSON can narrow the gap dramatically.
The article shares Google SRE veteran Minghua Ye’s insights on App Engine’s evolution, emphasizing the critical role of automatic scalability, distributed locks, service discovery, load balancing, and open‑source tools like gRPC, Protobuf, gflags, glog, and Googletest in building reliable, high‑traffic cloud services.
This article details the design and implementation of a Go‑based backend for a ride‑hailing app, covering real‑time vehicle tracking, route planning with OSRM, bandwidth‑saving UDP + ProtoBuf communication, in‑memory storage, R‑tree indexing, and the full API workflow.
This article describes how a ride‑hailing service built a memory‑based backend that animates cars on a map, covering challenges of sparse GPS updates, route planning with OSRM, protocol selection (UDP), data serialization (Protobuf), storage architecture, geospatial indexing with R‑tree, and the final API design.
This article provides a comprehensive overview of Hyperledger Fabric’s architecture, detailing its three core components, key terminology, protobuf definitions for transactions, blocks and messages, chaincode development in Go, and proposed role‑based redesign for improved scalability.
PhxRPC is a compact, 450KB RPC framework from the WeChat backend team that uses Protobuf for IDL, offers semi‑sync/async processing with Epoll‑based IO threads, provides built‑in overload protection, and includes performance benchmarks, usage instructions, and code generation details.
