BestHub
Sign in
Tagged articles
98 articles
Page 1 of 1
SpringMeng
SpringMeng
Apr 14, 2026 · Frontend Development

How to Build Modern Java Desktop Apps with Shadcn UI, React, and JxBrowser

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).

DesktopJavaJxBrowser
0 likes · 7 min read
How to Build Modern Java Desktop Apps with Shadcn UI, React, and JxBrowser
Java Captain
Java Captain
Apr 7, 2026 · Frontend Development

How to Build a Cross‑Platform Java Desktop App with React and shadcn/ui

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.

Desktop UIJxBrowserProtobuf
0 likes · 6 min read
How to Build a Cross‑Platform Java Desktop App with React and shadcn/ui
Go Development Architecture Practice
Go Development Architecture Practice
Mar 27, 2026 · Backend Development

Exploring Gin 1.12: BSON Support, Enhanced Context, Flexible Binding, and Protobuf Negotiation

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.

BSONGinGo
0 likes · 10 min read
Exploring Gin 1.12: BSON Support, Enhanced Context, Flexible Binding, and Protobuf Negotiation
Ray's Galactic Tech
Ray's Galactic Tech
Mar 16, 2026 · Backend Development

Mastering Production‑Ready HTTP Microservices with Go and Kratos

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.

DockerHTTP APIKratos
0 likes · 25 min read
Mastering Production‑Ready HTTP Microservices with Go and Kratos
Tech Freedom Circle
Tech Freedom Circle
Nov 18, 2025 · Backend Development

Optimizing Internal HTTP Calls: From Head‑of‑Line Blocking to High‑Performance Microservices

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.

Connection PoolingHTTP/2Microservices
0 likes · 32 min read
Optimizing Internal HTTP Calls: From Head‑of‑Line Blocking to High‑Performance Microservices
Data STUDIO
Data STUDIO
Nov 17, 2025 · Backend Development

Why ditch JSON? 4 binary formats that can make your API up to 5× faster

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.

API performanceCBORFlatBuffers
0 likes · 10 min read
Why ditch JSON? 4 binary formats that can make your API up to 5× faster
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Nov 16, 2025 · Backend Development

How to Choose and Implement Architecture Contracts for Distributed Systems

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.

Distributed SystemsProtobufarchitecture contracts
0 likes · 11 min read
How to Choose and Implement Architecture Contracts for Distributed Systems
php Courses
php Courses
Jun 16, 2025 · Backend Development

Build High‑Performance Go Microservices with gRPC and Protobuf

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.

GoProtobufgRPC
0 likes · 7 min read
Build High‑Performance Go Microservices with gRPC and Protobuf
FunTester
FunTester
May 27, 2025 · Backend Development

Java Serialization: Ten Common Pitfalls and Safer Alternatives

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.

JSONJavaProtobuf
0 likes · 18 min read
Java Serialization: Ten Common Pitfalls and Safer Alternatives
Tencent Cloud Developer
Tencent Cloud Developer
Apr 28, 2025 · Backend Development

Performance Optimization Techniques for High‑Throughput Backend Systems

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.

Backend DevelopmentCCache Friendly
0 likes · 16 min read
Performance Optimization Techniques for High‑Throughput Backend Systems
Deepin Linux
Deepin Linux
Apr 22, 2025 · Backend Development

C++ Serialization: Concepts, Tools, and Best Practices

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.

C++CerealCista++
0 likes · 41 min read
C++ Serialization: Concepts, Tools, and Best Practices
Tencent Cloud Developer
Tencent Cloud Developer
Apr 17, 2025 · Fundamentals

Protobuf Encoding Principles and Optimization Techniques

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.

Data StructuresProtobufProtocol Buffers
0 likes · 15 min read
Protobuf Encoding Principles and Optimization Techniques
Radish, Keep Going!
Radish, Keep Going!
Mar 14, 2025 · Backend Development

Why gRPC’s Code Generation Can Be Ugly—and How to Fix It

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.

Backend DevelopmentCode GenerationProtobuf
0 likes · 18 min read
Why gRPC’s Code Generation Can Be Ugly—and How to Fix It
Bilibili Tech
Bilibili Tech
Dec 27, 2024 · Big Data

Consistency Architecture for Bilibili Recommendation Model Data Flow

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.

Data ConsistencyFlinkIceberg
0 likes · 12 min read
Consistency Architecture for Bilibili Recommendation Model Data Flow
Code Mala Tang
Code Mala Tang
Dec 17, 2024 · Backend Development

Why gRPC Beats REST+JSON: HTTP/2 and Protobuf Performance Secrets

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.

HTTP/2ProtobufgRPC
0 likes · 7 min read
Why gRPC Beats REST+JSON: HTTP/2 and Protobuf Performance Secrets
Java Tech Enthusiast
Java Tech Enthusiast
Dec 15, 2024 · Fundamentals

Java Serialization and Deserialization: Concepts and Practices

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.

DeserializationHessianJSON
0 likes · 8 min read
Java Serialization and Deserialization: Concepts and Practices
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2024 · Backend Development

Contract-Based Design and Communication Challenges in Software Development

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.

OpenAPIProtobufcommunication
0 likes · 18 min read
Contract-Based Design and Communication Challenges in Software Development
MoonWebTeam
MoonWebTeam
Nov 16, 2024 · Backend Development

Unlocking TRPC: How Frontend Engineers Can Master RPC Architecture and Protobuf

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.

MicroservicesNode.jsProtobuf
0 likes · 51 min read
Unlocking TRPC: How Frontend Engineers Can Master RPC Architecture and Protobuf
ITPUB
ITPUB
Nov 1, 2024 · Backend Development

Why Our Nginx Data Gateway OOM’d: Tracing Memory Spikes & Core Dumps

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.

Batch ProcessingOOMProtobuf
0 likes · 16 min read
Why Our Nginx Data Gateway OOM’d: Tracing Memory Spikes & Core Dumps
Open Source Tech Hub
Open Source Tech Hub
Oct 31, 2024 · Big Data

How Bilibili Scaled Its Search Index with Distributed KV Storage and Spark

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.

Big DataKV StoreProtobuf
0 likes · 25 min read
How Bilibili Scaled Its Search Index with Distributed KV Storage and Spark
Architect
Architect
Sep 24, 2024 · Industry Insights

How Bilibili Re‑engineered Its Search Indexing Pipeline for Hour‑Level Turnaround

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.

Big DataDistributed SystemsProtobuf
0 likes · 24 min read
How Bilibili Re‑engineered Its Search Indexing Pipeline for Hour‑Level Turnaround
Bilibili Tech
Bilibili Tech
Aug 13, 2024 · Big Data

How Bilibili Re‑engineered Its Search Indexing with Distributed Storage and Spark

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.

Big DataBilibiliKV Store
0 likes · 24 min read
How Bilibili Re‑engineered Its Search Indexing with Distributed Storage and Spark
Ops Development & AI Practice
Ops Development & AI Practice
Jun 16, 2024 · Backend Development

Mastering Protocol Buffers 3: From Installation to Real-World Usage

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.

ProtobufProtocol BuffersPython
0 likes · 7 min read
Mastering Protocol Buffers 3: From Installation to Real-World Usage
FunTester
FunTester
Apr 12, 2024 · Backend Development

Performance Optimization Techniques for Backend Systems: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Data Structures

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.

Backend DevelopmentCCache Friendly
0 likes · 15 min read
Performance Optimization Techniques for Backend Systems: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Data Structures
IT Services Circle
IT Services Circle
Apr 11, 2024 · Backend Development

An Introduction to TypeSpec: Features, Usage Examples, and Quick Start Guide

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.

Backend DevelopmentCode GenerationOpenAPI
0 likes · 5 min read
An Introduction to TypeSpec: Features, Usage Examples, and Quick Start Guide
Architect
Architect
Mar 12, 2024 · Backend Development

Boost C++ Service Performance: 3× Faster with Classes, Cache‑Friendly Structures, jemalloc and Lock‑Free Designs

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.

BenchmarkCCache Friendly
0 likes · 20 min read
Boost C++ Service Performance: 3× Faster with Classes, Cache‑Friendly Structures, jemalloc and Lock‑Free Designs
High Availability Architecture
High Availability Architecture
Mar 6, 2024 · Backend Development

Performance Optimization Techniques: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Designs

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.

CCache FriendlyProtobuf
0 likes · 17 min read
Performance Optimization Techniques: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Designs
Tencent Cloud Developer
Tencent Cloud Developer
Feb 29, 2024 · Backend Development

Performance Optimization Strategies for High‑Throughput Backend Services

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.

BackendC++Cache Friendly
0 likes · 18 min read
Performance Optimization Strategies for High‑Throughput Backend Services
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 1, 2024 · Backend Development

Introducing Hasaki: A Simple Golang HTTP Restful Client with Custom Decoders and Middleware

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.

Custom DecoderGoHTTP client
0 likes · 10 min read
Introducing Hasaki: A Simple Golang HTTP Restful Client with Custom Decoders and Middleware
Architect
Architect
Dec 8, 2023 · Frontend Development

How to Build a Reliable, Low‑Latency IM Chat for Customer Service – Front‑End Techniques Revealed

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.

IMMessage OrderingProtobuf
0 likes · 24 min read
How to Build a Reliable, Low‑Latency IM Chat for Customer Service – Front‑End Techniques Revealed
Bilibili Tech
Bilibili Tech
Oct 17, 2023 · Artificial Intelligence

Design and Implementation of Bilibili Video Template System

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.

AI integrationComponentizationProtobuf
0 likes · 20 min read
Design and Implementation of Bilibili Video Template System
DeWu Technology
DeWu Technology
Oct 16, 2023 · Backend Development

Technical and Design Considerations for Customer Service IM Message Delivery

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.

Frontend OptimizationIMMessage Reliability
0 likes · 20 min read
Technical and Design Considerations for Customer Service IM Message Delivery
Bitu Technology
Bitu Technology
Jan 11, 2023 · Backend Development

Optimizing Performance, Stability, and Edge Cases of Elixir‑gRPC Services in Production

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.

ElixirEnvoyHTTP/2
0 likes · 13 min read
Optimizing Performance, Stability, and Edge Cases of Elixir‑gRPC Services in Production
Shopee Tech Team
Shopee Tech Team
Jul 21, 2022 · Cloud Native

Design and Implementation of Shopee Games Unified API Gateway

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.

GoMicroservicesProtobuf
0 likes · 23 min read
Design and Implementation of Shopee Games Unified API Gateway
Ctrip Technology
Ctrip Technology
Jul 7, 2022 · Mobile Development

Performance Optimization Practices for a Flutter‑Based Hotel App at Ctrip

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.

FlutterMobile DevelopmentProtobuf
0 likes · 22 min read
Performance Optimization Practices for a Flutter‑Based Hotel App at Ctrip
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Jun 29, 2022 · Artificial Intelligence

Music FeatureBox: A Custom Feature Store for Machine Learning at NetEase Cloud Music

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.

DataHubFeature StoreMLOps
0 likes · 17 min read
Music FeatureBox: A Custom Feature Store for Machine Learning at NetEase Cloud Music
FunTester
FunTester
May 7, 2022 · Backend Development

Hands‑On Guide to Building and Testing gRPC Services with Go

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.

BackendGoProtobuf
0 likes · 6 min read
Hands‑On Guide to Building and Testing gRPC Services with Go
BaiPing Technology
BaiPing Technology
Apr 11, 2022 · Backend Development

Automating API Development with Protobuf, GitLab CI, and Kratos

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.

API engineeringApifoxGo
0 likes · 20 min read
Automating API Development with Protobuf, GitLab CI, and Kratos
Architect
Architect
Dec 5, 2021 · Backend Development

Design and Optimization of Baidu Short Video Push System

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.

ProtobufPush Systemdistributed architecture
0 likes · 15 min read
Design and Optimization of Baidu Short Video Push System
Baidu Geek Talk
Baidu Geek Talk
Nov 15, 2021 · Backend Development

Baidu Short Video Push System: Architecture Design and Billion-Level Data Optimization Practice

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.

BaiduBitmap IndexProtobuf
0 likes · 15 min read
Baidu Short Video Push System: Architecture Design and Billion-Level Data Optimization Practice
Tencent Cloud Developer
Tencent Cloud Developer
Nov 10, 2021 · Backend Development

Protobuf Shared‑Field Guard for Zero‑Copy User Feature Propagation in Recommendation Systems

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.

Performance OptimizationProtobufZero Copy
0 likes · 7 min read
Protobuf Shared‑Field Guard for Zero‑Copy User Feature Propagation in Recommendation Systems
Tencent Cloud Developer
Tencent Cloud Developer
Aug 31, 2021 · Backend Development

Fundamentals of gRPC: Concepts, Asynchronous Client/Server, Streaming, Protocol and Generated Code

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.

AsynchronousC++Protobuf
0 likes · 22 min read
Fundamentals of gRPC: Concepts, Asynchronous Client/Server, Streaming, Protocol and Generated Code
Top Architect
Top Architect
Aug 3, 2021 · Backend Development

Java Serialization vs Binary Encoding: Size and Performance Comparison

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.

JavaProtobufThrift
0 likes · 6 min read
Java Serialization vs Binary Encoding: Size and Performance Comparison
Senior Brother's Insights
Senior Brother's Insights
Aug 2, 2021 · Backend Development

Mastering Protocol Buffers: From Installation to Java Integration

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.

ProtobufProtocol BuffersRPC
0 likes · 12 min read
Mastering Protocol Buffers: From Installation to Java Integration
Tencent Cloud Middleware
Tencent Cloud Middleware
Jul 13, 2021 · Backend Development

Why Kratos Is the Go Microservice Framework You Need: Protobuf, DI, and OpenTelemetry Explained

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.

GoKratosMicroservices
0 likes · 18 min read
Why Kratos Is the Go Microservice Framework You Need: Protobuf, DI, and OpenTelemetry Explained
Selected Java Interview Questions
Selected Java Interview Questions
Jun 9, 2021 · Backend Development

Understanding Java Serialization: Limitations, Performance Comparison, and Alternative Frameworks

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.

ByteBufferJavaProtobuf
0 likes · 7 min read
Understanding Java Serialization: Limitations, Performance Comparison, and Alternative Frameworks
21CTO
21CTO
Apr 24, 2021 · Backend Development

Unlocking C++ Performance: Surprising Memory‑Access Tricks from Baidu Engineers

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.

Backend DevelopmentC++Performance Optimization
0 likes · 33 min read
Unlocking C++ Performance: Surprising Memory‑Access Tricks from Baidu Engineers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 24, 2021 · Backend Development

How WeChat and Momo Solve Mobile IM Challenges: Protocols, Power Saving, and Massive Scaling

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.

IM architectureMomoProtobuf
0 likes · 12 min read
How WeChat and Momo Solve Mobile IM Challenges: Protocols, Power Saving, and Massive Scaling
DeWu Technology
DeWu Technology
Feb 19, 2021 · Backend Development

Understanding Protobuf Serialization in Dubbo with Protostuff

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.

DubboProtobufProtostuff
0 likes · 12 min read
Understanding Protobuf Serialization in Dubbo with Protostuff
Laiye Technology Team
Laiye Technology Team
Nov 4, 2020 · Backend Development

Protobuf Practices and Lessons Learned at Laiye Technology

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.

API documentationMicroservicesProtobuf
0 likes · 17 min read
Protobuf Practices and Lessons Learned at Laiye Technology
Tencent Cloud Developer
Tencent Cloud Developer
Oct 30, 2020 · Backend Development

Rebuilding QQ Mail Full-Text Search with Elasticsearch: Architecture, Implementation, and Optimization

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.

Backend ArchitectureCloud ServicesElasticsearch
0 likes · 17 min read
Rebuilding QQ Mail Full-Text Search with Elasticsearch: Architecture, Implementation, and Optimization
ITPUB
ITPUB
Oct 29, 2020 · Databases

Why MongoDB Needs an External Schema and How Protobuf/Thrift Can Help

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.

Database designMongoDBNoSQL
0 likes · 7 min read
Why MongoDB Needs an External Schema and How Protobuf/Thrift Can Help
Programmer DD
Programmer DD
Sep 29, 2020 · Backend Development

How JD’s HotKey Middleware Boosts Backend Performance via Protobuf

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.

Backend MiddlewareHot Data DetectionHotKey
0 likes · 5 min read
How JD’s HotKey Middleware Boosts Backend Performance via Protobuf
The Dominant Programmer
The Dominant Programmer
Sep 20, 2020 · Backend Development

Integrating Protobuf with Netty for Java Object Transmission

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.

Code ExampleJavaNetty
0 likes · 8 min read
Integrating Protobuf with Netty for Java Object Transmission
Programmer DD
Programmer DD
Sep 9, 2020 · Backend Development

How to Integrate Spring Boot with Netty Using Protobuf for Efficient Data Transfer

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.

Data TransferNettyProtobuf
0 likes · 20 min read
How to Integrate Spring Boot with Netty Using Protobuf for Efficient Data Transfer
Programmer DD
Programmer DD
May 5, 2020 · Backend Development

How to Build a High‑Concurrency Live Quiz System: Architecture & Tech Stack

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.

Backend ArchitectureProtobufWebSocket
0 likes · 18 min read
How to Build a High‑Concurrency Live Quiz System: Architecture & Tech Stack
58 Tech
58 Tech
Mar 16, 2020 · Fundamentals

Understanding Object Serialization: Principles, Frameworks, and Performance Optimizations

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.

Big DataBinaryMicroservices
0 likes · 16 min read
Understanding Object Serialization: Principles, Frameworks, and Performance Optimizations
High Availability Architecture
High Availability Architecture
Jan 8, 2020 · Backend Development

Apache Dubbo 2.7.5 Release: New Features, Performance Boosts, and Cloud‑Native Enhancements

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.

Cloud NativeDubboProtobuf
0 likes · 17 min read
Apache Dubbo 2.7.5 Release: New Features, Performance Boosts, and Cloud‑Native Enhancements
21CTO
21CTO
Jan 2, 2020 · Backend Development

Mastering API Design: Principles, Protobuf, RESTful, Swagger, and gRPC Explained

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.

HTTP/2ProtobufRESTful
0 likes · 29 min read
Mastering API Design: Principles, Protobuf, RESTful, Swagger, and gRPC Explained
MOMOLive Tech Team
MOMOLive Tech Team
Sep 24, 2019 · Backend Development

How Momo Live’s IM Architecture Scaled from V1 to V2

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.

Backend ArchitectureInstant MessagingProtobuf
0 likes · 9 min read
How Momo Live’s IM Architecture Scaled from V1 to V2
Amap Tech
Amap Tech
Sep 12, 2019 · Big Data

Exploring Map Data Serialization Techniques at Gaode

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.

FlatBuffersProtobufcompression
0 likes · 10 min read
Exploring Map Data Serialization Techniques at Gaode
360 Tech Engineering
360 Tech Engineering
Aug 21, 2019 · Backend Development

Practical Guide to gRPC Development for the Huajiao Service Backend

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.

Backend DevelopmentGoMicroservices
0 likes · 12 min read
Practical Guide to gRPC Development for the Huajiao Service Backend
GF Securities FinTech
GF Securities FinTech
Jul 5, 2019 · Frontend Development

Cut Frontend Bundle Size Using Webpack Analyzer and Babel

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.

Protobufbabelbundle optimization
0 likes · 9 min read
Cut Frontend Bundle Size Using Webpack Analyzer and Babel
JD Tech
JD Tech
Jan 4, 2019 · Backend Development

Using Protobuf with Go: Installation, Code Examples, and Serialization

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.

GoProtobufProtocol Buffers
0 likes · 6 min read
Using Protobuf with Go: Installation, Code Examples, and Serialization
360 Quality & Efficiency
360 Quality & Efficiency
Oct 12, 2018 · Backend Development

Automated Testing and Monitoring Solution for DSP Advertising Business

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.

Automated TestingDSPElasticsearch
0 likes · 8 min read
Automated Testing and Monitoring Solution for DSP Advertising Business
dbaplus Community
dbaplus Community
Mar 29, 2018 · Backend Development

When to Split a Monolith into Microservices: Practical Guidelines and a Step‑by‑Step Example

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.

Backend ArchitectureGoProtobuf
0 likes · 10 min read
When to Split a Monolith into Microservices: Practical Guidelines and a Step‑by‑Step Example
Tencent Cloud Developer
Tencent Cloud Developer
Mar 23, 2018 · Mobile Development

Building Custom Android Studio Plugins to Automate Code Generation

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.

Android Studio PluginAutomationCode Generation
0 likes · 10 min read
Building Custom Android Studio Plugins to Automate Code Generation
Architecture Digest
Architecture Digest
Jul 24, 2017 · Backend Development

Technical Overview of JD's Open Platform: High‑Performance API Gateway and Reliable Messaging Service

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.

ProtobufTCPrate limiting
0 likes · 12 min read
Technical Overview of JD's Open Platform: High‑Performance API Gateway and Reliable Messaging Service
Baidu Waimai Technology Team
Baidu Waimai Technology Team
Jul 4, 2017 · Operations

Building a Full‑Stack Operations Monitoring System: Strategies, Implementation & Lessons

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.

Log MonitoringPerformance MonitoringProtobuf
0 likes · 13 min read
Building a Full‑Stack Operations Monitoring System: Strategies, Implementation & Lessons
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Apr 14, 2017 · Information Security

Implementing a Lightweight User Authentication Mechanism for Hadoop at Tongcheng Travel

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.

AuthenticationHadoopKerberos
0 likes · 9 min read
Implementing a Lightweight User Authentication Mechanism for Hadoop at Tongcheng Travel
High Availability Architecture
High Availability Architecture
Mar 31, 2017 · Backend Development

Benchmarking JSON vs Protobuf Performance in Java

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.

BenchmarkJSONJava
0 likes · 22 min read
Benchmarking JSON vs Protobuf Performance in Java
Efficient Ops
Efficient Ops
Mar 26, 2017 · Operations

How Google Scales App Engine: Lessons in Cloud Scalability and SRE

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.

Distributed SystemsGoogle App EngineProtobuf
0 likes · 12 min read
How Google Scales App Engine: Lessons in Cloud Scalability and SRE
21CTO
21CTO
Mar 1, 2017 · Backend Development

How We Built a Scalable Uber‑Like Backend with Go, UDP & ProtoBuf

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.

GoOSRMProtobuf
0 likes · 10 min read
How We Built a Scalable Uber‑Like Backend with Go, UDP & ProtoBuf
High Availability Architecture
High Availability Architecture
Feb 28, 2017 · Backend Development

Designing a Backend System for an Uber‑Like Ride‑Hailing App with Animated Map Cars Using Go

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.

BackendGoProtobuf
0 likes · 9 min read
Designing a Backend System for an Uber‑Like Ride‑Hailing App with Animated Map Cars Using Go
21CTO
21CTO
Nov 6, 2015 · Backend Development

How WeChat & Momo Scale IM: Lessons on Battery, Network, and Custom Protocols

This article analyzes the architectural choices behind WeChat and Momo instant‑messaging services, covering battery and traffic constraints, network reliability, the shift from XMPP to proprietary long/short connections, protocol design with protobuf, and operational strategies for scaling massive user bases.

Backend ArchitectureInstant MessagingProtobuf
0 likes · 12 min read
How WeChat & Momo Scale IM: Lessons on Battery, Network, and Custom Protocols
Architect
Architect
Jul 27, 2015 · Backend Development

Design and Architecture of Specialized Search Services

The article explains the concept of specialized search, its service model, and detailed backend architecture considerations such as interface standards, traffic distribution, service invocation, and component reuse, illustrated with protobuf definitions and deployment diagrams.

BackendProtobufSearch
0 likes · 8 min read
Design and Architecture of Specialized Search Services