BestHub
Sign in
Tagged articles
190 articles
Page 1 of 2
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
DeepHub IMBA
DeepHub IMBA
Apr 4, 2026 · Artificial Intelligence

Building Mini-vLLM from Scratch: KV‑Cache, Dynamic Batching, and Distributed Inference

This article walks through constructing Mini-vLLM, a from‑scratch LLM inference engine that tackles the O(N²) attention cost with KV‑cache, boosts throughput via dynamic batching, adds observability with Prometheus/Grafana, supports gRPC, and scales across multiple workers, with benchmark numbers demonstrating its CPU‑only performance.

DockerDynamic BatchingInference Engine
0 likes · 12 min read
Building Mini-vLLM from Scratch: KV‑Cache, Dynamic Batching, and Distributed Inference
Woodpecker Software Testing
Woodpecker Software Testing
Mar 23, 2026 · Artificial Intelligence

Practical Guide to Optimizing AI Testing Tool Performance

This article analyzes why AI‑driven testing tools often become performance bottlenecks, identifies I/O and serialization as the main culprits, and presents concrete optimizations—including headless browser flags, mmap, gRPC streaming, model lightweighting, multi‑level caching, and Kubernetes‑based co‑scheduling—that together reduce latency by up to 90% and boost throughput severalfold.

AI testingKubernetesONNX
0 likes · 7 min read
Practical Guide to Optimizing AI Testing Tool Performance
Deepin Linux
Deepin Linux
Mar 17, 2026 · Backend Development

How to Build a High‑Performance gRPC File Transfer Service from Scratch

This step‑by‑step tutorial shows how to configure gRPC, define protobuf service contracts, and implement streaming upload and download in C++, covering environment setup, code generation, server and client logic, testing, and performance tuning for efficient file transfer.

C++MicroservicesProtocol Buffers
0 likes · 44 min read
How to Build a High‑Performance gRPC File Transfer Service from Scratch
Code Wrench
Code Wrench
Feb 12, 2026 · Backend Development

Why Bidirectional Streaming in gRPC Is More Than a Pipe – A Deep Dive into grpc-go

This article explores how gRPC bidirectional streaming transforms a simple data pipe into a conversational session by examining the underlying HTTP/2 mechanics, shared state machines, flow‑control strategies, practical patterns, and common pitfalls in grpc-go implementations.

Bidirectional StreamingDistributed SystemsFlow Control
0 likes · 16 min read
Why Bidirectional Streaming in gRPC Is More Than a Pipe – A Deep Dive into grpc-go
Code Wrench
Code Wrench
Feb 11, 2026 · Backend Development

Why gRPC Is More Than an RPC Framework: It’s a New Connection Primitive

This article reveals that gRPC should be seen not merely as a high‑performance RPC framework but as a novel connection primitive that treats network links as living, stateful entities, reshaping how developers design, monitor, and reason about distributed systems.

StreamingconnectiongRPC
0 likes · 12 min read
Why gRPC Is More Than an RPC Framework: It’s a New Connection Primitive
Go Development Architecture Practice
Go Development Architecture Practice
Jan 28, 2026 · Backend Development

Accelerate Go Projects with Mix‑Go: Build CLI, API, Web, gRPC & Worker Pools Fast

This guide introduces Mix‑Go, a Go‑based rapid‑development framework that provides interactive scaffolding, command‑line prototyping, and a DI/IoC container, and walks through installing the tool, generating project skeletons, and creating functional CLI, API, Web, WebSocket, gRPC services and a worker‑pool queue consumer with complete code examples.

APICLIGo
0 likes · 28 min read
Accelerate Go Projects with Mix‑Go: Build CLI, API, Web, gRPC & Worker Pools Fast
Go Development Architecture Practice
Go Development Architecture Practice
Jan 28, 2026 · Backend Development

Mastering gRPC with Python: From Basics to Real‑World Microservices

This guide explains the fundamentals of gRPC, why it uses HTTP/2 and Protocol Buffers, walks through writing and compiling .proto files, provides complete Python server and client examples, and outlines common microservice and Kubernetes use cases, giving developers a practical end‑to‑end workflow.

Backend DevelopmentMicroservicesProtocol Buffers
0 likes · 11 min read
Mastering gRPC with Python: From Basics to Real‑World Microservices
Top Architect
Top Architect
Jan 17, 2026 · Backend Development

Why We Rebuilt a Java Scheduler and How the New Lightweight Framework Works

Faced with limitations of existing tools like Quartz, XXL-Job, and PowerJob, the author explains the motivation for creating a custom scheduling framework, describes its architecture—including gRPC communication, protobuf serialization, a self-implemented name server for load balancing, a simple message queue, and time-wheel scheduling—provides code examples, and shares diagrams of discovery and dispatch processes.

Distributed SystemsJavaMessage Queue
0 likes · 17 min read
Why We Rebuilt a Java Scheduler and How the New Lightweight Framework Works
DeWu Technology
DeWu Technology
Dec 15, 2025 · Backend Development

How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios

This article explores five typical high‑concurrency, high‑availability scenarios—gRPC microservice communication, real‑time WebSocket messaging, API‑gateway rate limiting and circuit breaking, Redis‑Stream task queues, and Redis RedLock distributed locks—detailing the problems, Go‑centric solutions, code implementations, and supporting theory.

GoWebSocketgRPC
0 likes · 47 min read
How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios
Tencent Cloud Middleware
Tencent Cloud Middleware
Dec 9, 2025 · Cloud Native

How Tencent Cloud’s Virtual Queue Enables Seamless Compatibility for RocketMQ 5.x Remoting Clients

The article explains how RocketMQ 5.x’s storage‑compute decoupling and POP consumption model require a new gRPC client, and how Tencent Cloud’s virtual‑queue solution provides full compatibility for legacy Remoting SDKs by abstracting queues and transparently converting consumption modes, eliminating client‑side rebalance and preserving order guarantees.

Cloud NativeCompatibilityMessaging
0 likes · 10 min read
How Tencent Cloud’s Virtual Queue Enables Seamless Compatibility for RocketMQ 5.x Remoting Clients
Java Companion
Java Companion
Nov 29, 2025 · Backend Development

Why Do We Still Need HTTP and RPC When TCP Exists?

The article explains how TCP provides reliable byte‑stream transport but lacks message boundaries, how HTTP adds structured semantics with headers like Content‑Length, and why RPC frameworks such as gRPC are introduced to make remote calls feel like local method invocations, especially in modern microservice architectures.

HTTPMicroservicesRPC
0 likes · 11 min read
Why Do We Still Need HTTP and RPC When TCP Exists?
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
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 9, 2025 · Backend Development

Mastering Distributed Communication: Key Concepts and Frameworks for Scalable Backend Systems

This article explains the fundamentals of distributed communication, outlines essential elements such as serialization, transport protocols, service discovery, load balancing, security, and reliability, and reviews popular frameworks like gRPC, Dubbo, Thrift, and OpenFeign for building robust backend architectures.

Backend ArchitectureDubbogRPC
0 likes · 5 min read
Mastering Distributed Communication: Key Concepts and Frameworks for Scalable Backend Systems
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Nov 2, 2025 · Backend Development

Why Strict and Loose Contracts Matter in Microservice Architecture

This article explores the role of contracts in software architecture, explaining why architectural-level contract decisions are crucial, comparing strict and loose contracts such as gRPC, REST, and key‑value formats, and introducing consumer‑driven contracts, their trade‑offs, and practical guidelines for reducing coupling and brittleness in microservices.

Consumer-Driven ContractsMicroservicescontract design
0 likes · 15 min read
Why Strict and Loose Contracts Matter in Microservice Architecture
IT Architects Alliance
IT Architects Alliance
Oct 21, 2025 · Backend Development

How to Crush Microservice Communication Bottlenecks: Protocols, Meshes, and Code

Microservice architectures face severe communication bottlenecks due to network overhead, serialization costs, and connection management, but by adopting high‑performance protocols like gRPC, leveraging service meshes, optimizing load balancing, caching, connection pools, and robust monitoring, teams can dramatically improve latency and throughput.

MicroservicesService MeshgRPC
0 likes · 12 min read
How to Crush Microservice Communication Bottlenecks: Protocols, Meshes, and Code
Open Source Tech Hub
Open Source Tech Hub
Sep 21, 2025 · Backend Development

Boost PHP API Platform Performance with Go-Powered gRPC Services

Learn how to combine PHP's ease of use with Go's high-performance concurrency by integrating gRPC services into an API Platform project, covering environment setup, protobuf definitions, Go server implementation, PHP client integration, and troubleshooting tips to dramatically reduce API latency.

API PlatformBackendGo
0 likes · 8 min read
Boost PHP API Platform Performance with Go-Powered gRPC Services
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 18, 2025 · Backend Development

Choosing the Right API Protocol: From RESTful to GraphQL, gRPC, WebSocket, and SSE

This article, based on the open‑source HiMarket project, systematically compares six mainstream API protocols—from classic RESTful and SOAP to modern GraphQL, microservice‑focused RPC frameworks, real‑time WebSocket, and streaming SSE—detailing their core concepts, technical traits, advantages, and ideal application scenarios.

APIGraphQLMicroservices
0 likes · 17 min read
Choosing the Right API Protocol: From RESTful to GraphQL, gRPC, WebSocket, and SSE
AntTech
AntTech
Aug 27, 2025 · Mobile Development

How Alipay Built an AI Travel Assistant in Two Months with xUI, gRPC, and KMP

This article details the two‑month end‑to‑end development of Alipay's AI Travel Assistant, describing the product concept, technical background, adoption of the xUI interaction framework, gRPC streaming, Kotlin Multiplatform integration, migration challenges, performance metrics, and future roadmap.

AICross‑PlatformKotlin Multiplatform
0 likes · 23 min read
How Alipay Built an AI Travel Assistant in Two Months with xUI, gRPC, and KMP
Alipay Experience Technology
Alipay Experience Technology
Aug 26, 2025 · Mobile Development

How Alipay Built an AI Travel Assistant in Two Months with a 4‑Person Mobile Team

This article details the end‑to‑end development of Alipay’s AI Travel Assistant, covering product conception, the migration to a unified xUI 1.0 framework, the adoption of KMP for cross‑platform UI, the shift from RPC + SYNC to gRPC streaming, and the challenges of card‑ecosystem migration, all achieved within a two‑month sprint by a four‑person client team.

AIChatbotKMP
0 likes · 25 min read
How Alipay Built an AI Travel Assistant in Two Months with a 4‑Person Mobile Team
Wukong Talks Architecture
Wukong Talks Architecture
Aug 14, 2025 · Backend Development

Understanding RocketMQ Architecture: Components, Protocols, and Storage

This article provides a comprehensive overview of RocketMQ's architecture, detailing its core components, network protocols, storage mechanisms, producer‑consumer workflow, and transactional messaging, while highlighting differences between Remoting and gRPC and explaining key design choices for high performance and reliability.

Message QueueNettyRocketMQ
0 likes · 15 min read
Understanding RocketMQ Architecture: Components, Protocols, and Storage
Architecture Digest
Architecture Digest
Jul 24, 2025 · Backend Development

RPC vs HTTP: Which Wins for Enterprise Services?

This article compares RPC and HTTP services, explains the OSI model layers relevant to each, details RPC architecture components, discusses synchronous and asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for large‑scale enterprise applications.

Backend DevelopmentDubboHTTP
0 likes · 9 min read
RPC vs HTTP: Which Wins for Enterprise Services?
Architect
Architect
Jul 14, 2025 · Backend Development

Why RPC Beats HTTP: Architecture, Sync/Async, and Top Frameworks

This article compares RPC and HTTP services, explains the OSI seven‑layer model, details RPC architecture and its synchronous versus asynchronous calls, reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose RPC over HTTP for enterprise applications.

Backend DevelopmentDubboHTTP
0 likes · 9 min read
Why RPC Beats HTTP: Architecture, Sync/Async, and Top Frameworks
Code Wrench
Code Wrench
Jul 13, 2025 · Backend Development

Boost Go Web Performance with Asynchronous Logging via Channels and Middleware

This article explains how to build a high‑performance asynchronous logging system for Go web services using channels and middleware, covering both gRPC and Gin implementations, a log‑processing engine, performance‑tuning tips, and measured latency and CPU improvements.

ChannelsGinasynchronous logging
0 likes · 7 min read
Boost Go Web Performance with Asynchronous Logging via Channels and Middleware
Code Wrench
Code Wrench
Jul 9, 2025 · Backend Development

Boost Go Microservices with gRPC over HTTP/3: A Hands‑On Guide

This article demonstrates how to build high‑performance, low‑latency Go microservices by integrating gRPC with HTTP/3 over QUIC, covering server and client implementations, a sample Analyze service, step‑by‑step communication flow, and performance comparisons against traditional HTTP/2‑based gRPC.

Backend DevelopmentGoHTTP/3
0 likes · 9 min read
Boost Go Microservices with gRPC over HTTP/3: A Hands‑On Guide
Code Wrench
Code Wrench
Jul 8, 2025 · Backend Development

Automate Go gRPC API Docs in 3 Steps: Swagger Integration & Live Debugging

Learn how to eliminate manual API documentation in Go gRPC projects by automatically generating Swagger docs from Proto annotations, syncing with code changes, and enabling interactive testing, using tools like Buf, grpc-gateway, and Swagger UI in a concise three‑step workflow.

API documentationAutomationSwagger
0 likes · 5 min read
Automate Go gRPC API Docs in 3 Steps: Swagger Integration & Live Debugging
FunTester
FunTester
Jul 2, 2025 · Backend Development

Master Non‑Blocking & Streaming gRPC Clients in Java for High‑Performance Testing

Learn how to create and use non‑blocking (asynchronous) and streaming gRPC clients in Java, covering stub creation, request handling with ListenableFuture, blocking vs listener approaches, and stream observer implementation, enabling high‑concurrency performance testing and real‑time data processing scenarios.

AsynchronousJavaPerformance Testing
0 likes · 7 min read
Master Non‑Blocking & Streaming gRPC Clients in Java for High‑Performance Testing
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
Java Architect Essentials
Java Architect Essentials
Jun 10, 2025 · Backend Development

Why Rebuild a Distributed Scheduler? Inside a Custom Java Job Framework

This article explains the motivations behind creating a new distributed scheduling framework, compares existing solutions, and details the design choices—including gRPC communication, protobuf serialization, a custom NameServer for load balancing, and a built‑in message queue with persistence and retry mechanisms—to handle frequent task creation and dynamic parameter changes in a high‑concurrency environment.

Distributed SchedulingTime WheelgRPC
0 likes · 14 min read
Why Rebuild a Distributed Scheduler? Inside a Custom Java Job Framework
Java Tech Enthusiast
Java Tech Enthusiast
May 23, 2025 · Databases

MySQL Indexes, ACID, Raft, and gRPC: Technical Interview Insights

This article combines a Meituan salary update with detailed explanations of MySQL indexing strategies, B‑tree variations, ACID transaction properties, isolation levels, caching, handling high‑traffic queries, the Raft consensus algorithm, and an overview of gRPC, providing comprehensive backend development knowledge for interview preparation.

ACIDBackendRaft
0 likes · 17 min read
MySQL Indexes, ACID, Raft, and gRPC: Technical Interview Insights
Architect
Architect
May 3, 2025 · Backend Development

Why Rebuild a Job Scheduler? Inside a Lightweight Distributed Timing Framework

This article explains the motivation, design choices, and implementation details of a custom distributed job scheduling framework, covering its architecture, load‑balancing strategy, message‑queue handling, persistence mechanisms, and key code snippets, while comparing it to existing solutions like Quartz, XXL‑Job, and PowerJob.

Distributed SystemsJavaMessage Queue
0 likes · 16 min read
Why Rebuild a Job Scheduler? Inside a Lightweight Distributed Timing Framework
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
Radish, Keep Going!
Radish, Keep Going!
Mar 12, 2025 · Backend Development

Why gRPC Beats REST: Performance, Contracts, and Streaming Explained

gRPC offers superior performance, efficient Protobuf encoding, strong API contracts, seamless streaming, cross‑language support, and HTTP/2 advantages, making it a compelling alternative to REST for modern web services, while tools like gRPC‑Gateway, ConnectRPC, and Buf streamline migration and ecosystem integration.

API contractsStreaminggRPC
0 likes · 10 min read
Why gRPC Beats REST: Performance, Contracts, and Streaming Explained
Radish, Keep Going!
Radish, Keep Going!
Jan 16, 2025 · Backend Development

How Hedged Requests Cut Tail Latency in Go Microservices

This article explains the hedged request pattern used by Google to combat microservice tail latency, shows how to implement it in Go with context and goroutines, discusses its impact on latency and load, and explores additional techniques such as SingleFlight and service‑class prioritization to further reduce tail delays.

Backend PerformanceGoMicroservices
0 likes · 6 min read
How Hedged Requests Cut Tail Latency in Go Microservices
JD Tech Talk
JD Tech Talk
Jan 10, 2025 · Backend Development

Analysis of gRPC: Principles, Advantages, Disadvantages, and a Cross‑Language Demo

This article examines gRPC’s implementation principles, multi‑language support, Protocol Buffers foundation, advantages and disadvantages, and provides a C++/Go demo illustrating its cross‑language capabilities within cloud‑native environments, including project structure, code snippets, and discussion of HTTP/2 transport.

Cross-languageHTTP/2Protocol Buffers
0 likes · 8 min read
Analysis of gRPC: Principles, Advantages, Disadvantages, and a Cross‑Language Demo
JD Cloud Developers
JD Cloud Developers
Jan 10, 2025 · Backend Development

Why gRPC Is the Go-To RPC Framework for Multi-Language Backend Services

This article examines gRPC’s implementation principles, its multi‑language support, Protocol Buffers integration, performance advantages, and limitations such as browser compatibility, while providing a C++/Go demo that showcases cross‑language RPC calls and a detailed project structure.

Backend DevelopmentCross-languageProtocol Buffers
0 likes · 9 min read
Why gRPC Is the Go-To RPC Framework for Multi-Language Backend Services
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jan 3, 2025 · Backend Development

Mastering gRPC Retry: Strategies, Configurations, and Best Practices

This article examines common short‑term failure causes in shared‑resource environments, explains gRPC’s retry configuration options and implementation details, and provides practical guidance on setting retry policies, backoff strategies, and status code handling to improve service resilience.

BackoffError HandlinggRPC
0 likes · 10 min read
Mastering gRPC Retry: Strategies, Configurations, and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Dec 24, 2024 · Backend Development

Design and Implementation of a Custom Distributed Job Scheduling Framework (k‑job)

This article introduces the motivation, architecture, technology choices, and key implementation details of a lightweight, highly extensible distributed job scheduling framework built on gRPC, Protobuf, a custom name‑server, and a bespoke message‑queue, addressing limitations of existing solutions like Quartz, XXL‑Job, and PowerJob.

Distributed SystemsJavaJob Scheduling
0 likes · 14 min read
Design and Implementation of a Custom Distributed Job Scheduling Framework (k‑job)
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Dec 20, 2024 · Backend Development

Go‑Zero Load Balancing Explained: Stateless vs Stateful Algorithms and gRPC Integration

This article explores the fundamentals of load balancing in microservice architectures, detailing both stateless and stateful strategies such as round‑robin, random, hash, and weighted algorithms, and demonstrates how go‑zero and gRPC implement these mechanisms through custom balancers, service discovery, and request scheduling.

gRPCgo-zeroload balancing
0 likes · 11 min read
Go‑Zero Load Balancing Explained: Stateless vs Stateful Algorithms and gRPC Integration
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
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Oct 31, 2024 · Backend Development

Boosting Ozone Block Reads with gRPC Streaming: Up to 30% Faster

This article explains how a gRPC bidirectional streaming read method was added to Ozone to reduce chunk‑by‑chunk request gaps, describes the client‑side implementation, presents single‑ and multi‑threaded performance tests showing roughly 30% faster reads, and outlines future enhancements such as pre‑fetching.

OzoneStreamingblock storage
0 likes · 7 min read
Boosting Ozone Block Reads with gRPC Streaming: Up to 30% Faster
Deepin Linux
Deepin Linux
Sep 19, 2024 · Backend Development

Comprehensive Guide to gRPC: Concepts, C++ Implementation, and Real‑World Use Cases

This article explains the limitations of traditional RPC, introduces gRPC and Protocol Buffers, details their architecture and performance advantages, provides step‑by‑step C++ server and client code, and discusses practical scenarios such as microservices, real‑time data processing, and a file‑storage service example.

C++Distributed SystemsMicroservices
0 likes · 29 min read
Comprehensive Guide to gRPC: Concepts, C++ Implementation, and Real‑World Use Cases
Sohu Tech Products
Sohu Tech Products
Sep 5, 2024 · Backend Development

Instrumentation of gRPC in OpenTelemetry: Adding Request Size Metrics via Byte‑Buddy

The new OpenTelemetry Java instrumentation adds client and server request‑size metrics to gRPC by injecting a tracing interceptor via Byte‑Buddy bytecode enhancement, extracting payload sizes from protobuf messages, recording them with custom attributes and histograms, and applying analogous handler‑based logic for Go.

ByteBuddyInstrumentationJava
0 likes · 12 min read
Instrumentation of gRPC in OpenTelemetry: Adding Request Size Metrics via Byte‑Buddy
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 4, 2024 · Backend Development

Mastering Distributed RPC: Principles, Workflows, and Top Frameworks Explained

This article explains the fundamentals of distributed RPC, outlines its end‑to‑end communication workflow, and compares major frameworks such as gRPC, Apache Thrift, Dubbo, Spring Cloud Netflix, ZeroMQ, Apache Avro, and gRPC‑Web, helping developers choose the right solution for their microservice architecture.

Backend ArchitectureDubboMicroservices
0 likes · 6 min read
Mastering Distributed RPC: Principles, Workflows, and Top Frameworks Explained
Code Mala Tang
Code Mala Tang
Jun 15, 2024 · Fundamentals

Why ProtoBuf Is the Future of Efficient Data Serialization

This article explains what Protocol Buffers (ProtoBuf) are, how they work, their key advantages over JSON and XML, practical usage patterns with code examples, compression mechanisms, real‑world applications, and best practices for maintaining compatibility in modern software systems.

binary protocoldata serializationgRPC
0 likes · 16 min read
Why ProtoBuf Is the Future of Efficient Data Serialization
Huolala Tech
Huolala Tech
May 28, 2024 · Backend Development

How HuoLala’s “Lingmu” Platform Revolutionizes Map Service Testing with Real‑Time Traffic Replay

This article details the design and implementation of HuoLala’s Lingmu platform, which provides zero‑intrusive traffic recording, gRPC‑compatible replay, multi‑level diff noise reduction, and intelligent problem analysis to dramatically improve map service testing coverage, accuracy, and development efficiency.

Software Testingbackend platformdiff analysis
0 likes · 16 min read
How HuoLala’s “Lingmu” Platform Revolutionizes Map Service Testing with Real‑Time Traffic Replay
21CTO
21CTO
May 25, 2024 · Backend Development

Mastering E‑Commerce API Design: Best Practices, Protocols, and Versioning

This article walks developers through the fundamentals of designing robust e‑commerce APIs, covering CRUD operations, protocol choices such as REST, GraphQL and gRPC, versioning strategies, rate limiting, CORS, and best practices for request idempotency and backward compatibility.

CRUDGraphQLVersioning
0 likes · 8 min read
Mastering E‑Commerce API Design: Best Practices, Protocols, and Versioning
MaGe Linux Operations
MaGe Linux Operations
Mar 10, 2024 · Backend Development

Mastering RPC: From Concepts to gRPC Implementation in Go

This article explains the fundamentals of Remote Procedure Call (RPC), its historical origins, the step‑by‑step execution process, and provides a practical guide to installing and using gRPC with Protocol Buffers in Go, including full code examples and advantages.

Backend DevelopmentGoMicroservices
0 likes · 14 min read
Mastering RPC: From Concepts to gRPC Implementation in Go
php Courses
php Courses
Jan 30, 2024 · Backend Development

Guide to Configuring a PHP gRPC Client with Docker and Composer

This tutorial provides a step‑by‑step guide to configuring a PHP gRPC client using proto files, Composer, Docker, and Docker‑Compose, covering project structure, code generation, autoload setup, Dockerfile creation, and client execution in a containerized environment.

BackendComposerMicroservices
0 likes · 9 min read
Guide to Configuring a PHP gRPC Client with Docker and Composer
Su San Talks Tech
Su San Talks Tech
Jan 3, 2024 · Backend Development

How Nacos Implements Service Registration: From Ephemeral Instances to CP/AP Consistency

This article deep‑dives into Nacos as a service registry, explaining the differences between temporary and permanent instances, registration mechanisms across 1.x and 2.x versions, heartbeat and health‑check strategies, service discovery methods, data‑consistency models, and the underlying data model that powers Nacos clusters.

ConsistencyHeartbeatNacos
0 likes · 28 min read
How Nacos Implements Service Registration: From Ephemeral Instances to CP/AP Consistency
DeWu Technology
DeWu Technology
Nov 15, 2023 · Backend Development

Thread Profiling: Design and Implementation of Client‑Server Performance Analysis

Thread profiling uses threshold‑triggered tasks on business threads to capture stack snapshots, which a dedicated profiler thread sends via high‑performance gRPC to a server that queues them in Kafka, enriches and stores them in ClickHouse, correlates with OpenTelemetry traces, and provides metrics that let developers quickly pinpoint latency bottlenecks and improve system stability.

GoJavaKafka
0 likes · 11 min read
Thread Profiling: Design and Implementation of Client‑Server Performance Analysis
Bilibili Tech
Bilibili Tech
Oct 10, 2023 · Backend Development

Design and Implementation of a Scalable Live‑Streaming Full‑Stream Data System

The article details a scalable live‑stream full‑stream data system that replaces a tightly‑coupled legacy architecture with a producer‑consumer model using a custom key‑value store, bucket sharding, gRPC server‑streaming, versioned caching, and comprehensive observability, achieving sub‑second queries, horizontal scalability, and reliable support for thousands of downstream services.

Observabilitydata pipelinegRPC
0 likes · 18 min read
Design and Implementation of a Scalable Live‑Streaming Full‑Stream Data System
JD Cloud Developers
JD Cloud Developers
Sep 18, 2023 · Backend Development

Mastering Rust gRPC Streaming with Tonic: Build Server & Client

This guide walks through creating a Rust project that uses the Tonic library to implement gRPC streaming, covering project setup, protobuf definitions, server and client code, testing with grpcurl, and enabling the reflection API for service introspection.

AsyncBackendRust
0 likes · 15 min read
Mastering Rust gRPC Streaming with Tonic: Build Server & Client
Goodme Frontend Team
Goodme Frontend Team
Sep 18, 2023 · Backend Development

Demystifying RPC: From OSI Layers to Node.js JSON‑RPC Implementation

This article explains the fundamentals of Remote Procedure Call (RPC), explores how data moves across OSI layers, compares HTTP and RPC, and provides a complete Node.js JSON‑RPC example with code, error handling, and real‑world use cases such as Chrome DevTools Protocol.

Backend DevelopmentChrome DevToolsJSON-RPC
0 likes · 13 min read
Demystifying RPC: From OSI Layers to Node.js JSON‑RPC Implementation
Programmer DD
Programmer DD
Sep 13, 2023 · Backend Development

6 Common API Patterns Every Developer Should Master

This article presents a concise animated overview of six widely used API patterns—gRPC, SOAP, GraphQL, WebHook, REST, and WebSocket—explaining their core concepts, typical use cases, and relevance in modern software development, and points to short video tutorials for deeper understanding.

API patternsGraphQLWebSocket
0 likes · 4 min read
6 Common API Patterns Every Developer Should Master
Bilibili Tech
Bilibili Tech
Sep 8, 2023 · Backend Development

Investigation of Goroutine Leak in Go

The article details how a sudden surge in goroutine and heap usage was traced to repeatedly creating gRPC clients instead of reusing a singleton, leading to blocked goroutines and TCP connections, and explains using pprof, stack traces, and tools like goleak to detect and prevent such leaks.

DebuggingGoGo Programming
0 likes · 13 min read
Investigation of Goroutine Leak in Go
Sanyou's Java Diary
Sanyou's Java Diary
Sep 4, 2023 · Backend Development

Inside Nacos Dynamic Service Discovery: Architecture, Protocols, and Code

This article explains the fundamentals of Nacos dynamic service discovery, covering its purpose, communication protocols, registration, heartbeat, subscription, push mechanisms, and client querying, and includes detailed code examples and diagrams to illustrate the internal processes and performance improvements.

Dynamic RegistrationNacosgRPC
0 likes · 17 min read
Inside Nacos Dynamic Service Discovery: Architecture, Protocols, and Code
Alibaba Cloud Native
Alibaba Cloud Native
Aug 18, 2023 · Cloud Native

Choosing Between Dubbo, Spring Cloud, gRPC, and Istio: A Practical Guide

Developers and architects can compare Apache Dubbo, Spring Cloud, gRPC, and Istio across architecture, performance, scalability, and governance, gaining clear guidance on selecting the right micro‑service framework and understanding each tool’s strengths, protocol support, and integration patterns for enterprise‑grade cloud‑native applications.

IstioMicroservicesService Mesh
0 likes · 11 min read
Choosing Between Dubbo, Spring Cloud, gRPC, and Istio: A Practical Guide
JavaEdge
JavaEdge
Aug 1, 2023 · Backend Development

Explore IntelliJ IDEA 2023.2: New Profiling, Debugging, and Cloud Tools

IntelliJ IDEA 2023.2 introduces a suite of enhancements—including a Run‑window profiler, inline return breakpoints, automatic test reruns for Gradle/Maven/JPS, WSL‑based Tomcat debugging, TLS‑enabled gRPC requests, Swagger and OpenAPI support, shared index generation, and numerous UI and code‑completion upgrades—streamlining Java development workflows.

DebuggingIntelliJ IDEAJava
0 likes · 12 min read
Explore IntelliJ IDEA 2023.2: New Profiling, Debugging, and Cloud Tools
Alibaba Cloud Native
Alibaba Cloud Native
Jul 19, 2023 · Cloud Native

Why Dubbo’s New Triple Protocol Beats gRPC for Cloud‑Native Microservices

The article explains how Dubbo 3’s upgraded Triple protocol, fully compatible with gRPC and runnable over HTTP/1 and HTTP/2, simplifies client and server integration, reduces development and operational costs, and offers multi‑language support, making it a practical choice for cloud‑native microservice architectures.

Cloud NativegRPCtriple-protocol
0 likes · 12 min read
Why Dubbo’s New Triple Protocol Beats gRPC for Cloud‑Native Microservices
Architects Research Society
Architects Research Society
Jul 3, 2023 · Backend Development

Performance Comparison of REST, gRPC, and Asynchronous Communication in Microservices

This article evaluates the impact of three microservice communication styles—REST, gRPC, and asynchronous messaging via RabbitMQ—on functional and non‑functional software quality attributes, presenting experimental results from a Kubernetes‑based order‑processing scenario that show gRPC delivering the best performance across varying loads.

KubernetesMicroservicesRabbitMQ
0 likes · 13 min read
Performance Comparison of REST, gRPC, and Asynchronous Communication in Microservices
Liangxu Linux
Liangxu Linux
Jun 12, 2023 · Backend Development

Choosing Between RPC and HTTP: When Speed, Flexibility, and Governance Matter

This article compares RPC and HTTP interfaces, detailing their architectures, popular frameworks, performance characteristics, load‑balancing, and service‑governance features, and provides practical guidance on selecting the right approach for internal high‑performance services or external cross‑platform APIs.

DubboHTTPRESTful
0 likes · 9 min read
Choosing Between RPC and HTTP: When Speed, Flexibility, and Governance Matter
Laravel Tech Community
Laravel Tech Community
Jun 11, 2023 · Backend Development

Eclipse Vert.x 4.4.3 Release Notes: New Features, Improvements, and Bug Fixes

Eclipse Vert.x 4.4.3 introduces a series of updates across core components—including JDBC client tracing fixes, GraphQL-Java upgrade, enhanced gRPC support, Netty and Hazelcast upgrades, new Consul ACL API, Infinispan lock handling, SSL option improvements, Groovy 4.0.12, and various bug fixes—strengthening its lightweight, high‑performance, asynchronous backend framework.

AsynchronousBackendJava
0 likes · 4 min read
Eclipse Vert.x 4.4.3 Release Notes: New Features, Improvements, and Bug Fixes
Java Architect Essentials
Java Architect Essentials
May 19, 2023 · Backend Development

Understanding the Differences Between RPC and HTTP Services

This article explains the fundamental differences between RPC and HTTP services, covering OSI model layers, RPC architecture components, synchronous vs asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and when to choose each approach for enterprise applications.

Backend DevelopmentDubboHTTP
0 likes · 9 min read
Understanding the Differences Between RPC and HTTP Services
Top Architect
Top Architect
May 3, 2023 · Backend Development

Integrating Dubbo with SpringBoot Using gRPC: Project Structure, Maven Configuration, and Code Samples

This article provides a step‑by‑step guide on how to integrate Dubbo with SpringBoot to enable the gRPC protocol, covering project structure, Maven BOM dependencies, protobuf generation, service implementation, configuration details, and the differences between Dubbo‑enabled gRPC and native gRPC.

DubboMicroservicesSpringBoot
0 likes · 18 min read
Integrating Dubbo with SpringBoot Using gRPC: Project Structure, Maven Configuration, and Code Samples
Java Captain
Java Captain
Apr 18, 2023 · Fundamentals

Understanding the Differences Between RPC and HTTP Services

This article explains the fundamental distinctions between RPC and HTTP services by reviewing the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and the typical use cases of each approach.

DubboHTTPNetwork Protocols
0 likes · 8 min read
Understanding the Differences Between RPC and HTTP Services
21CTO
21CTO
Feb 21, 2023 · Backend Development

REST vs gRPC: Which API Framework Wins for Modern Microservices?

This article explains the fundamentals of REST and gRPC APIs, compares their design constraints, features, and typical use cases, and helps developers choose the most suitable framework for building scalable, high‑performance microservice architectures.

APIBackend DevelopmentMicroservices
0 likes · 10 min read
REST vs gRPC: Which API Framework Wins for Modern Microservices?
MaGe Linux Operations
MaGe Linux Operations
Jan 24, 2023 · Backend Development

Why RPC Beats HTTP for Enterprise Services: A Deep Dive

This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose each approach for enterprise applications.

BackendDubboHTTP
0 likes · 10 min read
Why RPC Beats HTTP for Enterprise Services: A Deep Dive
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
Alibaba Cloud Native
Alibaba Cloud Native
Dec 27, 2022 · Cloud Native

Contribute to Apache RocketMQ 5.0 SDK: New Cloud‑Native Features & How‑to Guide

Apache RocketMQ 5.0 introduces a stateless proxy, gRPC‑based multi‑language SDK with immutable APIs, enhanced error handling, SimpleConsumer, and pop consumption, and the article outlines the technical improvements, roadmap, and step‑by‑step guide for developers to set up the environment, understand the new protocols, and contribute language client implementations.

Cloud NativeMessage QueueRocketMQ
0 likes · 8 min read
Contribute to Apache RocketMQ 5.0 SDK: New Cloud‑Native Features & How‑to Guide
Liangxu Linux
Liangxu Linux
Dec 20, 2022 · Backend Development

Why RPC Outperforms HTTP: OSI Layers, Architecture & Top Frameworks

This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right communication approach for enterprise applications.

Backend DevelopmentDubboHTTP
0 likes · 9 min read
Why RPC Outperforms HTTP: OSI Layers, Architecture & Top Frameworks
Alibaba Cloud Native
Alibaba Cloud Native
Nov 28, 2022 · Cloud Native

Why Proxyless Service Mesh Could Replace Sidecars: A Hands‑On Istio Demo

This article introduces Service Mesh fundamentals, traces its evolution to Istio, explains the Proxyless Mesh architecture that eliminates sidecar proxies, and provides a step‑by‑step Spring Cloud demo showing how to enable xDS‑based, sidecar‑free communication across multi‑language microservices on Alibaba Cloud MSE.

IstioMicroservicesService Mesh
0 likes · 10 min read
Why Proxyless Service Mesh Could Replace Sidecars: A Hands‑On Istio Demo
Bilibili Tech
Bilibili Tech
Nov 18, 2022 · Operations

Chaos Engineering and Fault Injection System Design: Principles, Implementation, and Practice

Chaos Engineering and Fault Injection System Design combine steady-state hypotheses, controlled blast-radius experiments, and a lightweight interceptor layer using gRPC and protobuf to inject and report faults in micro-service architectures, enabling continuous testing, rapid MTTR reduction, and resilient services through automated, real-time experimentation and analysis.

Fault InjectionGoReliability Testing
0 likes · 15 min read
Chaos Engineering and Fault Injection System Design: Principles, Implementation, and Practice
Open Source Linux
Open Source Linux
Oct 18, 2022 · Backend Development

Master gRPC: Build High‑Performance RPC Services with Python

gRPC is a high‑performance, open‑source RPC framework built on HTTP/2 and Protocol Buffers, and this guide explains its core concepts, communication patterns, protobuf usage, and provides step‑by‑step Python examples for creating, compiling, and running client‑server services, plus deployment tips.

HTTP/2Protocol BuffersPython
0 likes · 10 min read
Master gRPC: Build High‑Performance RPC Services with Python
Efficient Ops
Efficient Ops
Oct 10, 2022 · Backend Development

Master gRPC: From Basics to Building a Python Microservice

This article introduces gRPC, explains its HTTP/2 and Protocol Buffers foundations, walks through writing and compiling .proto files, provides complete Python server and client examples, and shows how to quickly set up the environment and integrate gRPC into microservice and Kubernetes deployments.

Backend DevelopmentHTTP/2Protocol Buffers
0 likes · 9 min read
Master gRPC: From Basics to Building a Python Microservice