BestHub
Sign in
Tagged articles

grpc

201 articles · Page 1 of 3
Java Tech Enthusiast
Java Tech Enthusiast
Jun 30, 2026 · Backend Development

Spring Boot 4.1.0 Released: Official gRPC Support Boosts Java Microservices

Spring Boot 4.1.0 introduces official gRPC support, unified Jackson configuration, HTTP client SSRF protection, enhanced observability with OpenTelemetry, and flexible Log4j file‑rotation strategies, while the roadmap confirms a one‑year lifecycle for each version and signals the shift to the 4.x era for Java microservices.

JavaObservabilitySpring Boot
0 likes · 8 min read
Spring Boot 4.1.0 Released: Official gRPC Support Boosts Java Microservices
java1234
java1234
Jun 25, 2026 · Backend Development

Spring Boot 4.1.0 Released: gRPC Auto‑Config, SSRF‑Safe HTTP Client, Lazy JDBC, @RedisListener and OpenTelemetry Enhancements

Spring Boot 4.1.0, launched on June 10, 2026, adds built‑in gRPC server/client auto‑configuration, an InetAddressFilter to block SSRF attacks, lazy JDBC connection fetching, automatic @RedisListener registration, unified Jackson settings, OpenTelemetry improvements and several other developer‑experience upgrades, all illustrated with runnable demos and migration tips.

Backend DevelopmentOpenTelemetrySpring Boot
0 likes · 13 min read
Spring Boot 4.1.0 Released: gRPC Auto‑Config, SSRF‑Safe HTTP Client, Lazy JDBC, @RedisListener and OpenTelemetry Enhancements
Java Tech Enthusiast
Java Tech Enthusiast
Jun 21, 2026 · Backend Development

Spring Boot 4.1.0: Deep Dive into 8 Must‑Know Production Features

Spring Boot 4.1.0, released on June 10, 2026, adds official gRPC support, built‑in SSRF protection, OpenTelemetry enhancements, lazy datasource initialization, async context propagation, Kotlin 2.3 compatibility, Log4j file‑rotation, and numerous build‑tool and dependency upgrades, while providing a detailed migration guide for production environments.

Build ToolsKotlinLazy DataSource
0 likes · 17 min read
Spring Boot 4.1.0: Deep Dive into 8 Must‑Know Production Features
Su San Talks Tech
Su San Talks Tech
Jun 16, 2026 · Backend Development

Spring Boot 4.1.0 Released – 8 Core New Features Every Developer Should Know

Spring Boot 4.1.0, launched on June 10 2026, builds on Spring Framework 7.0.x and adds eight production‑grade features—including official gRPC support, built‑in SSRF protection, OpenTelemetry enhancements, lazy datasource connections, Kotlin 2.3 support, and upgraded logging—while also detailing migration steps, deprecated APIs, and best‑fit scenarios.

KotlinLazy DataSourceOpenTelemetry
0 likes · 17 min read
Spring Boot 4.1.0 Released – 8 Core New Features Every Developer Should Know
Architect's Tech Stack
Architect's Tech Stack
Jun 15, 2026 · Backend Development

Spring Boot 4.1.0 Released: Production‑Ready Features You Should Know

Spring Boot 4.1.0 builds on the 4.x foundation by adding production‑focused enhancements such as native gRPC auto‑configuration, outbound SSRF protection, lazy JDBC connections, OpenTelemetry support, and updated Jackson 3 settings, while offering guidance on when and how to upgrade.

Backend DevelopmentJackson 3OpenTelemetry
0 likes · 13 min read
Spring Boot 4.1.0 Released: Production‑Ready Features You Should Know
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 11, 2026 · Backend Development

Spring Boot 4.1 Released: 20 New Features and Key Improvements

Spring Boot 4.1 introduces 20 major updates, including removal of deprecated APIs, new gRPC support, enhanced Jackson configuration, improved observability with OpenTelemetry, SSL for RabbitMQ streams, lazy JDBC connections, and numerous Gradle and Maven plugin enhancements, while providing detailed migration guidance for developers.

Docker ComposeJavaObservability
0 likes · 16 min read
Spring Boot 4.1 Released: 20 New Features and Key Improvements
AI Engineer Programming
AI Engineer Programming
May 23, 2026 · Artificial Intelligence

Is the A2A Protocol Worth Using? An In‑Depth Technical Review

The article examines the emerging A2A (Agent‑to‑Agent) protocol, tracing its evolution from function calling to MCP and finally A2A, and evaluates its core concepts, security model, task lifecycle, transport options, design guidelines, and operational best practices for building interoperable AI agent systems.

A2AAgent CardAgent communication
0 likes · 15 min read
Is the A2A Protocol Worth Using? An In‑Depth Technical Review
LuTiao Programming
LuTiao Programming
May 17, 2026 · Backend Development

What Is an API? Master the Basics in 10 Minutes

This article explains what an API is, how it acts as a communication middle‑man between clients and servers, walks through HTTP request components, compares REST, GraphQL, gRPC and WebSocket, shows practical code examples, status‑code meanings, and provides a step‑by‑step learning roadmap for beginners.

APIGraphQLHTTP
0 likes · 14 min read
What Is an API? Master the Basics in 10 Minutes
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 UIJxBrowserReAct
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 BatchingKV cache
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 testingCachingONNX
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
Golang Shines
Golang Shines
Mar 5, 2026 · Backend Development

Build a User CRUD Service from Scratch with Go‑Kratos

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.

CRUDClean ArchitectureGo
0 likes · 14 min read
Build a User CRUD Service from Scratch with Go‑Kratos
TonyBai
TonyBai
Mar 5, 2026 · Backend Development

Why Hand‑Typing protoc in 2026? Switch to Buf CLI for Modern Go + Protobuf

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.

CLIMicroservicesbsr
0 likes · 22 min read
Why Hand‑Typing protoc in 2026? Switch to Buf CLI for Modern Go + Protobuf
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.

JavaMessage QueueOpenAPI
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.

GoHigh concurrencyWebSocket
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 NativeRocketMQVirtual Queue
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?
Ray's Galactic Tech
Ray's Galactic Tech
Nov 28, 2025 · Operations

Enterprise Nginx Mastery: Rate Limiting, Load Balancing, WebSocket, gRPC & CDN

This comprehensive guide walks you through enterprise‑grade Nginx configurations—including core settings, rate limiting, reverse‑proxy best practices, load‑balancing strategies, uwsgi, static‑file optimization, WebSocket/gRPC support, CDN caching, and ready‑to‑use templates for diverse business scenarios.

CDNReverse ProxyWebSocket
0 likes · 8 min read
Enterprise Nginx Mastery: Rate Limiting, Load Balancing, WebSocket, gRPC & CDN
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.

CachingConnection PoolingHTTP/2
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.

Dubbobackend-architecturegrpc
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 ContractsMicroservicesREST
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.

MicroservicesMonitoringService Mesh
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 PlatformGoPHP
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.

AIChatbotCross-Platform
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.

Asynchronous LoggingChannelsGin
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.

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

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

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

JavaMessage Queuedistributed systems
0 likes · 16 min read
Why Rebuild a Job Scheduler? Inside a Lightweight Distributed Timing Framework
Ops Development & AI Practice
Ops Development & AI Practice
Apr 8, 2025 · Industry Insights

Which Protocol Fits Your AI Agent? STDIO, SSE, WebSockets, gRPC, Queues

This article examines the Multi‑Channel Protocol (MCP) for AI agents, comparing its primary communication options—STDIO and Server‑Sent Events—and exploring additional alternatives such as WebSockets, gRPC, and message queues, while offering guidance on selecting the most suitable protocol for various deployment scenarios.

MCPSSEcommunication protocols
0 likes · 11 min read
Which Protocol Fits Your AI Agent? STDIO, SSE, WebSockets, gRPC, Queues
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 generationgrpc
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.

JavaJob SchedulingMessage Queue
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.

go-zerogrpcload 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/2grpcprotobuf
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++MicroservicesProtocol Buffers
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.

DubboMicroservicesbackend-architecture
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.

Data Serializationbinary protocolgrpc
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.

backend platformdiff analysisgrpc
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.

API designCRUDGraphQL
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.

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

Service Registryconsistencygrpc
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.

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

Live StreamingObservabilitydata pipeline
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.

Streamingasyncbackend
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 patternsGraphQLREST
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.

GoGo ProgrammingGoroutine
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 Registrationgrpcnacos
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.

IntelliJ IDEAJavaProfiling
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.

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

AsynchronousJavaMicroservices
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
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