BestHub
Sign in
Tagged articles
2122 articles
Page 8 of 22
Programmer DD
Programmer DD
Jul 26, 2022 · Operations

Mastering Service Governance: From Distributed Systems to Reliable RPC Frameworks

This article explains the fundamentals of service governance in distributed systems, covering RPC communication, common anomalies, replica types, design principles, performance metrics, and the architecture and workflow of RPC frameworks, while also detailing key practices such as registration, discovery, load balancing, traffic shaping, version compatibility, circuit breaking, degradation, and rate limiting.

Distributed SystemsMicroservicesRPC
0 likes · 15 min read
Mastering Service Governance: From Distributed Systems to Reliable RPC Frameworks
Selected Java Interview Questions
Selected Java Interview Questions
Jul 25, 2022 · Backend Development

Four Approaches to Solving Session Management in Distributed Environments

This article examines four strategies for handling session data in distributed backend systems—session replication, client-side storage, hash-based load balancing, and centralized storage with Redis—detailing their principles, advantages, disadvantages, and practical recommendations for different deployment scales.

BackendDistributed SystemsSession
0 likes · 9 min read
Four Approaches to Solving Session Management in Distributed Environments
Top Architect
Top Architect
Jul 25, 2022 · Backend Development

Monolithic vs Microservice Architecture: Pros, Cons, Service Gateway, Registration, and Configuration Center

This article explains the differences between monolithic and microservice architectures, outlines their advantages and disadvantages, and then dives into essential components such as service gateways, service registration and discovery, and distributed configuration centers, providing practical guidance for building scalable backend systems.

Backend ArchitectureConfiguration CenterDistributed Systems
0 likes · 26 min read
Monolithic vs Microservice Architecture: Pros, Cons, Service Gateway, Registration, and Configuration Center
FunTester
FunTester
Jul 24, 2022 · Operations

Boost Service Reliability with Chaos Engineering: Practical Steps & Evaluation

Chaos engineering, a discipline for experimenting on distributed systems, helps teams identify hidden weaknesses, improve high‑availability, and build confidence in production by defining stable states, injecting realistic failures, and measuring impact through observability metrics, with practical steps, tool choices, maturity stages, and evaluation methods.

Distributed SystemsFault InjectionObservability
0 likes · 11 min read
Boost Service Reliability with Chaos Engineering: Practical Steps & Evaluation
Top Architect
Top Architect
Jul 23, 2022 · Cloud Native

Comprehensive Guide to etcd: Overview, Architecture, Deployment, and Usage

This article provides a detailed introduction to etcd, covering its purpose as a highly available distributed key‑value store, core concepts like Raft consensus, key features, common use cases such as service discovery and configuration management, step‑by‑step installation for single‑node and cluster deployments, and essential etcdctl commands for managing data and cluster members.

Cloud NativeConfiguration ManagementDistributed Systems
0 likes · 24 min read
Comprehensive Guide to etcd: Overview, Architecture, Deployment, and Usage
IT Architects Alliance
IT Architects Alliance
Jul 21, 2022 · Big Data

Explanation of Kafka Components and Architecture

This article provides a comprehensive overview of Kafka’s core components—including brokers, topics, partitions, producers, and consumers—explaining their roles, log structures, replication mechanisms, and the system’s architecture, supplemented with practical visual illustrative diagrams.

Distributed SystemsMessagingPartitioning
0 likes · 8 min read
Explanation of Kafka Components and Architecture
Meituan Technology Team
Meituan Technology Team
Jul 21, 2022 · Backend Development

Visualized Full‑Chain Log Tracing for Complex Business Systems

The article analyzes the shortcomings of traditional ELK and distributed tracing for complex business systems, proposes a visualized full‑chain log tracing solution that organizes and dynamically links logs by business chain, and demonstrates its implementation and performance gains at Meituan’s content platform.

BackendDSLDistributed Systems
0 likes · 26 min read
Visualized Full‑Chain Log Tracing for Complex Business Systems
FunTester
FunTester
Jul 21, 2022 · Databases

Scaling Databases with Distributed Sharding and Peak‑Shaving Strategies

The article explains why simply adding hardware cannot keep up with growing database workloads and presents a three‑step approach—business isolation, horizontal sharding, and advanced reporting using PolarDB‑X—to achieve high concurrency, elastic capacity, and efficient caching for modern high‑traffic applications.

Distributed SystemsPeak ShavingPolarDB-X
0 likes · 7 min read
Scaling Databases with Distributed Sharding and Peak‑Shaving Strategies
Architecture Digest
Architecture Digest
Jul 21, 2022 · Backend Development

Implementing a Reliable Redis‑Based Delay Queue in Go

This article explains how to design and implement a precise, persistent, and retry‑capable delay queue using Redis ordered sets and Lua scripts, provides a complete Go library with usage examples, and discusses the underlying data structures, atomic operations, and garbage‑collection mechanisms.

Distributed SystemsGoMessage Queue
0 likes · 11 min read
Implementing a Reliable Redis‑Based Delay Queue in Go
Java High-Performance Architecture
Java High-Performance Architecture
Jul 20, 2022 · Backend Development

Mastering Load Balancing: From Round Robin to Consistent Hashing in Java

This article explains common load‑balancing strategies—including round‑robin, random, weighted, smooth weighted round‑robin, consistent hashing, least‑active, and fastest‑response algorithms—provides Java implementations with code samples, discusses their advantages, disadvantages, and suitable scenarios, and offers practical guidance for choosing the right method in distributed systems.

Distributed SystemsRound Robinconsistent hashing
0 likes · 35 min read
Mastering Load Balancing: From Round Robin to Consistent Hashing in Java
Laravel Tech Community
Laravel Tech Community
Jul 19, 2022 · Backend Development

The Evolution and Architecture of China’s 12306 Railway Ticketing System

This article examines the historical development, distributed architecture, and high‑concurrency challenges of China’s 12306 railway ticketing platform, tracing its origins from early Unix‑based systems to modern multi‑layered backend solutions that support hundreds of millions of users during peak travel periods.

Backend ArchitectureDistributed SystemsRailway
0 likes · 8 min read
The Evolution and Architecture of China’s 12306 Railway Ticketing System
Baidu Geek Talk
Baidu Geek Talk
Jul 19, 2022 · Cloud Native

How OpenTelemetry and Jaeger Power Cloud‑Native Tracing

This article explains cloud‑native observability, defines its three pillars—metrics, tracing, and logging—details the OpenTelemetry tracing data model and Span structure, reviews industry implementations such as Jaeger and Alibaba Eagle Eye, and shares practical challenges and solutions from real‑world production use.

Alibaba Eagle EyeCloud NativeDistributed Systems
0 likes · 11 min read
How OpenTelemetry and Jaeger Power Cloud‑Native Tracing
Architect's Guide
Architect's Guide
Jul 19, 2022 · Backend Development

Design and Implementation of a Custom Java RPC Framework

This article presents a comprehensive overview of a hand‑crafted RPC framework built with Spring Boot, Netty, and Zookeeper, covering its core concepts, architecture, custom message protocol, load‑balancing strategies, serialization choices, starter design, deployment steps, and testing procedures.

Distributed SystemsNettyRPC
0 likes · 15 min read
Design and Implementation of a Custom Java RPC Framework
IT Architects Alliance
IT Architects Alliance
Jul 18, 2022 · Backend Development

Cache Design and Optimization Strategies in High‑Concurrency Distributed Systems

The article explains the benefits, costs, and various update, penetration, no‑hole, avalanche, and hot‑key optimization techniques for caching in high‑concurrency distributed systems, providing practical guidance on choosing appropriate strategies based on consistency requirements and system load.

Cache EvictionDistributed Systemscache-penetration
0 likes · 16 min read
Cache Design and Optimization Strategies in High‑Concurrency Distributed Systems
Top Architect
Top Architect
Jul 18, 2022 · Backend Development

Common Load Balancing Algorithms and Their Java Implementations

This article explains the principles behind popular load‑balancing strategies such as round‑robin, weighted round‑robin, smooth weighted round‑robin, consistent hashing, least‑active, and best‑response, and provides clear Java code examples for each method.

AlgorithmsBackendDistributed Systems
0 likes · 34 min read
Common Load Balancing Algorithms and Their Java Implementations
Java High-Performance Architecture
Java High-Performance Architecture
Jul 15, 2022 · Backend Development

How Meituan Built a High‑Performance Distributed Architecture for Instant Logistics

This article explains how Meituan's instant logistics platform evolved from a monolithic system to a highly available, scalable, and AI‑enhanced distributed architecture, detailing the technical challenges, architectural upgrades, fault‑tolerance strategies, and future scalability concerns.

AI integrationBackend ArchitectureDistributed Systems
0 likes · 10 min read
How Meituan Built a High‑Performance Distributed Architecture for Instant Logistics
Top Architect
Top Architect
Jul 15, 2022 · Backend Development

Design and Evolution of Meituan's Real-Time Logistics Distributed System

This article details Meituan's instant logistics platform architecture, covering its background, distributed system design, high‑availability deployment, AI‑driven optimization, and future challenges, while sharing practical solutions for scalability, fault tolerance, and operational efficiency in a high‑concurrency environment.

Distributed SystemsMeituanMicroservices
0 likes · 9 min read
Design and Evolution of Meituan's Real-Time Logistics Distributed System
IT Architects Alliance
IT Architects Alliance
Jul 14, 2022 · Operations

Common Load Balancing Algorithms and Their Java Implementations

This article reviews common load balancing strategies—including round-robin, random, weighted, smooth weighted round-robin, consistent hashing, least-active and optimal-response algorithms—explains their advantages and drawbacks, and provides complete Java code examples for each method.

AlgorithmsDistributed SystemsWeighted Round Robin
0 likes · 33 min read
Common Load Balancing Algorithms and Their Java Implementations
Architecture & Thinking
Architecture & Thinking
Jul 14, 2022 · Fundamentals

Understanding Message Queues: Execution Principles and Choosing the Right MQ

This article explains the fundamentals of message middleware, covering its architecture, components, communication models, advantages, common protocols, major open‑source solutions, detailed feature comparisons, and practical guidance for selecting the most suitable message queue based on system scale, business needs, performance, high availability, and operational considerations.

Distributed SystemsKafkaMQ
0 likes · 21 min read
Understanding Message Queues: Execution Principles and Choosing the Right MQ
Architect
Architect
Jul 12, 2022 · Backend Development

Load Balancing Algorithms: Round Robin, Random, Weighted, Smooth Weighted, Consistent Hashing, Least Active and Optimal Response

This article explains common load‑balancing strategies—including basic round‑robin, random, weighted and smooth weighted algorithms, as well as consistent hashing, least‑active and optimal‑response methods—provides Java implementations for each, discusses their advantages, disadvantages, and suitable scenarios, and concludes with practical recommendations.

AlgorithmsDistributed Systemsconsistent hashing
0 likes · 34 min read
Load Balancing Algorithms: Round Robin, Random, Weighted, Smooth Weighted, Consistent Hashing, Least Active and Optimal Response
Top Architect
Top Architect
Jul 12, 2022 · Backend Development

Understanding Interface Idempotency and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Guava RateLimiter, Nginx, and Redis+Lua

This article explains the concept of interface idempotency, demonstrates how to achieve idempotent update operations using version control and token mechanisms, and provides a comprehensive guide to distributed rate limiting—including time‑window and resource‑based dimensions, token‑bucket and leaky‑bucket algorithms, and practical implementations with Guava RateLimiter, Nginx, and Redis‑Lua scripts.

BackendDistributed SystemsIdempotency
0 likes · 21 min read
Understanding Interface Idempotency and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Guava RateLimiter, Nginx, and Redis+Lua
vivo Internet Technology
vivo Internet Technology
Jul 6, 2022 · Backend Development

RocketMQ Consumer Startup Process and Message Consumption Mechanisms

RocketMQ consumers initialize by validating configuration, creating subscription data, establishing a client instance, loading offsets, and starting services before registering with the client factory, after which they can receive messages via push (default low‑latency) or pull modes, support ordered processing, and handle acknowledgments with configurable retries and dead‑letter handling.

ConsumerDistributed SystemsRocketMQ
0 likes · 24 min read
RocketMQ Consumer Startup Process and Message Consumption Mechanisms
Top Architect
Top Architect
Jul 4, 2022 · Backend Development

High‑Concurrency Architecture Design and Practical Solutions

This article explains how to design and implement a high‑concurrency system for e‑commerce scenarios, covering server architecture, load balancing, database clustering, caching strategies, concurrency testing tools, message‑queue based async processing, first‑level cache, static data handling, layering, distribution, redundancy and automation, with concrete examples such as user sign‑in, order queries and red‑packet distribution.

Backend ArchitectureDistributed SystemsPerformance Testing
0 likes · 20 min read
High‑Concurrency Architecture Design and Practical Solutions
Cognitive Technology Team
Cognitive Technology Team
Jul 3, 2022 · Backend Development

Network Timeouts Do Not Imply Server Failure: Effective Retry, Backoff, and Idempotency Strategies

Network timeouts do not necessarily indicate server‑side failure; handling them with appropriate retry strategies, exponential backoff, and idempotent APIs—combined with mechanisms such as distributed locks and atomic transactions—helps maintain system stability while avoiding duplicate operations and resource exhaustion.

BackendBackoffDistributed Systems
0 likes · 7 min read
Network Timeouts Do Not Imply Server Failure: Effective Retry, Backoff, and Idempotency Strategies
Bilibili Tech
Bilibili Tech
Jun 24, 2022 · Cloud Native

Evolution and Design of Bilibili's Load‑Testing Platform (Platform 2.0)

Bilibili’s load‑testing platform evolved from ad‑hoc JMeter scripts to a fully automated, self‑service system (Platform 2.0) that uses a custom load client, adaptive scheduling, and flexible scenario modes—including traffic replay and data‑isolated testing—to efficiently stress‑test over a hundred microservices for large‑scale events, with further integration and circuit‑breaker enhancements planned.

Distributed SystemsLoad TestingMicroservices
0 likes · 27 min read
Evolution and Design of Bilibili's Load‑Testing Platform (Platform 2.0)
High Availability Architecture
High Availability Architecture
Jun 24, 2022 · Backend Development

Improving Cache Invalidation and Consistency at Scale

Meta engineers describe the challenges of cache invalidation and consistency in large‑scale distributed systems, explain why stale caches are problematic, present their Polaris observability service and consistency‑tracking techniques, and detail how they raised TAO’s cache consistency from six‑nines to ten‑nines.

ConsistencyDistributed SystemsObservability
0 likes · 17 min read
Improving Cache Invalidation and Consistency at Scale
macrozheng
macrozheng
Jun 24, 2022 · Backend Development

Choosing the Right Distributed ID Generator: UUID, Snowflake, NanoID

This article examines the trade‑offs of common distributed ID generators—UUID, timestamp‑based schemes, Snowflake, and NanoID—highlighting their size, ordering, performance, and security implications to help developers select the most suitable approach for their systems.

Distributed SystemsID generationnanoid
0 likes · 6 min read
Choosing the Right Distributed ID Generator: UUID, Snowflake, NanoID
DataFunTalk
DataFunTalk
Jun 23, 2022 · Big Data

Real‑Time Low‑Latency Log Monitoring and Storage at Ctrip: Architecture, Clog System, CAT Tracing, and TSDB

This article details Ctrip's large‑scale, real‑time log monitoring solution, covering the overall monitoring architecture, the Clog log system, the CAT tracing platform, and the TSDB metric store, and explains design choices such as write‑heavy indexing, segment‑based storage, and migration to ClickHouse for high‑cardinality data.

Distributed SystemsLog MonitoringReal-time Processing
0 likes · 11 min read
Real‑Time Low‑Latency Log Monitoring and Storage at Ctrip: Architecture, Clog System, CAT Tracing, and TSDB
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Jun 23, 2022 · Backend Development

Mastering Rate Limiting: Choosing the Right Algorithm for High‑Availability Systems

This article explores the importance of rate limiting in distributed micro‑service architectures, explains four core algorithms—fixed window, sliding window, leaky bucket, and token bucket—and details a practical, Redis‑backed multi‑layer throttling solution for a voice‑bot platform, including trade‑offs and implementation tips.

Distributed SystemsMicroservicesSliding Window
0 likes · 15 min read
Mastering Rate Limiting: Choosing the Right Algorithm for High‑Availability Systems
Wukong Talks Architecture
Wukong Talks Architecture
Jun 20, 2022 · Backend Development

Understanding the Eureka Service Heartbeat Mechanism in Microservices

This article explains how Eureka’s heartbeat mechanism works in microservice architectures, covering who sends the heartbeat, the scheduling interval, the request implementation, server-side handling, and the effect on service registration, using code examples and analogies to historical tribute systems.

Distributed SystemsHeartbeateureka
0 likes · 6 min read
Understanding the Eureka Service Heartbeat Mechanism in Microservices
转转QA
转转QA
Jun 20, 2022 · Operations

Issue 4: Technical Articles on Full‑Chain Stress Testing, Distributed Web UI Automation, WWDC22 Sessions, Efficient Automated Testing, and AutoDiff Traffic Replay

This issue curates five technical articles covering Gaode's full‑chain stress testing platform, a distributed web UI automation system, a comprehensive WWDC22 session review, ShouQianBa's efficient automated testing practices, and Autohome's AutoDiff traffic replay for integrated testing.

Distributed SystemsMobile DevelopmentPerformance
0 likes · 4 min read
Issue 4: Technical Articles on Full‑Chain Stress Testing, Distributed Web UI Automation, WWDC22 Sessions, Efficient Automated Testing, and AutoDiff Traffic Replay
ITPUB
ITPUB
Jun 19, 2022 · Backend Development

Mastering Cache Design: Solving the 7 Classic Pitfalls in High‑Traffic Systems

This article explores common cache challenges such as centralized expiration, cache penetration, avalanche, hot keys, large keys, data consistency, and concurrent pre‑warming, offering practical design patterns and mitigation strategies to build robust, high‑performance backend systems.

BackendCache DesignDistributed Systems
0 likes · 10 min read
Mastering Cache Design: Solving the 7 Classic Pitfalls in High‑Traffic Systems
Qunar Tech Salon
Qunar Tech Salon
Jun 16, 2022 · Operations

Practical Chaos Engineering Practices at Qunar Travel: Architecture, Scenarios, and Automation

This article details Qunar Travel's mature chaos engineering platform built on chaosblade, covering value analysis, system architecture, shutdown and dependency drills, automated closed‑loop testing, attack‑defense exercises, and the measurable reliability improvements achieved across thousands of services.

Distributed SystemsFault InjectionOperations
0 likes · 18 min read
Practical Chaos Engineering Practices at Qunar Travel: Architecture, Scenarios, and Automation
Java High-Performance Architecture
Java High-Performance Architecture
Jun 11, 2022 · Backend Development

Essential Microservice Architecture Patterns Every Backend Engineer Should Know

This article explores the core goals of microservice architecture, outlines key design principles such as scalability and resilience, and presents a comprehensive catalog of decomposition, integration, cross‑cutting concern, and observability patterns—including API gateway, Strangler, Bulkhead, Saga, and CQRS—to guide developers in building robust, maintainable backend systems.

ArchitectureBackendDistributed Systems
0 likes · 24 min read
Essential Microservice Architecture Patterns Every Backend Engineer Should Know
MaGe Linux Operations
MaGe Linux Operations
Jun 10, 2022 · Fundamentals

Demystifying Paxos: How Distributed Systems Achieve Consensus

This article explains the Paxos consensus algorithm—its origins, core concepts, roles of proposers, acceptors and learners, safety and liveness constraints, the two-phase protocol, proposal generation, and practical variations—showing why Paxos remains a foundational solution for fault‑tolerant distributed systems.

Consensus AlgorithmDistributed SystemsPaxos
0 likes · 16 min read
Demystifying Paxos: How Distributed Systems Achieve Consensus
ITPUB
ITPUB
Jun 10, 2022 · Operations

How Zookeeper Prevents Split‑Brain Failures in Distributed Clusters

This article explains the split‑brain phenomenon in distributed systems, illustrates how it can occur in Zookeeper clusters, and details Zookeeper's quorum‑based solutions—including majority voting, odd‑node deployment, and additional safeguards—to avoid split‑brain and ensure reliable leader election.

Distributed SystemsSplit-Brainleader election
0 likes · 11 min read
How Zookeeper Prevents Split‑Brain Failures in Distributed Clusters
Laiye Technology Team
Laiye Technology Team
Jun 10, 2022 · Backend Development

Understanding System Failures and Principles for Resilient Architecture

The article analyzes why modern software systems repeatedly collapse—due to growing business complexity, unpredictable changes, and architectural decay—and proposes principles such as decentralization, integration, and diversity, along with practical strategies like service mesh and eBPF, to design more sustainable, observable, and self‑evolving architectures.

ArchitectureDistributed SystemsMicroservices
0 likes · 12 min read
Understanding System Failures and Principles for Resilient Architecture
Sohu Tech Products
Sohu Tech Products
Jun 8, 2022 · Databases

Cache Working Mechanisms and Consistency Solutions Using Redis

This article explores Redis cache mechanisms, various caching patterns such as Cache‑Aside, Read‑Through, Write‑Through and Write‑Behind, analyzes consistency challenges in write operations, and presents solutions like delayed double deletion, retry mechanisms, and binlog‑based asynchronous cache invalidation to achieve eventual consistency.

Cache ConsistencyDistributed Systemscache-aside
0 likes · 18 min read
Cache Working Mechanisms and Consistency Solutions Using Redis
Efficient Ops
Efficient Ops
Jun 7, 2022 · Big Data

Visualizing Kafka: Core Concepts Explained with Diagrams

This article visually breaks down Kafka’s fundamental concepts—including topics, partitions, producers, consumers, consumer groups, and cluster architecture—so readers can grasp how messages flow, are stored, and achieve load balancing and ordering within a distributed streaming platform.

Distributed SystemsKafkaMessage Queue
0 likes · 6 min read
Visualizing Kafka: Core Concepts Explained with Diagrams
DataFunSummit
DataFunSummit
Jun 3, 2022 · Big Data

Building and Optimizing JD Retail OLAP Platform: Architecture, Management, and Performance Techniques

This article details JD Retail's OLAP platform construction, covering control plane design, architecture, business and operation management, real‑time data updates, materialized view usage, join optimizations, high‑concurrency and high‑throughput scenarios, and promotional preparation strategies, illustrated with diagrams and performance metrics.

Big DataClickHouseDistributed Systems
0 likes · 20 min read
Building and Optimizing JD Retail OLAP Platform: Architecture, Management, and Performance Techniques
Code Ape Tech Column
Code Ape Tech Column
May 27, 2022 · Backend Development

Comparison of Four Popular Open-Source Distributed Message Queues: Kafka, ActiveMQ, RabbitMQ, and RocketMQ

This article introduces and compares four widely used open-source distributed message-queue systems—Kafka, ActiveMQ, RabbitMQ, and RocketMQ—detailing their architectures, deployment requirements, features, high-availability solutions, advantages, disadvantages, and provides guidance for selecting the appropriate middleware in large-scale applications.

ActiveMQDistributed SystemsKafka
0 likes · 38 min read
Comparison of Four Popular Open-Source Distributed Message Queues: Kafka, ActiveMQ, RabbitMQ, and RocketMQ
macrozheng
macrozheng
May 26, 2022 · Backend Development

How RocketMQ Uses Queues, Page Cache, and mmap to Achieve High Performance and Scalability

This article explains how RocketMQ tackles registration latency, synchronous coupling, and traffic spikes by introducing an intermediate queue, designing a persistent high‑availability broker, leveraging Linux page cache and memory‑mapped files, and employing topics, tags, and sharding to enable efficient asynchronous processing and scalable consumption.

Distributed SystemsMessage QueueRocketMQ
0 likes · 28 min read
How RocketMQ Uses Queues, Page Cache, and mmap to Achieve High Performance and Scalability
Sohu Tech Products
Sohu Tech Products
May 25, 2022 · Backend Development

Design Principles of RocketMQ: Broker Architecture, Persistence, High Performance and High Availability

The article explains how RocketMQ tackles growing business traffic by introducing an asynchronous broker layer, using commitlog and consumeQueue files, page‑cache, mmap, topic/tag routing, and a nameserver to achieve high‑throughput, low‑latency, and highly available message delivery.

Distributed SystemsMessage QueueRocketMQ
0 likes · 30 min read
Design Principles of RocketMQ: Broker Architecture, Persistence, High Performance and High Availability
Zhuanzhuan Tech
Zhuanzhuan Tech
May 25, 2022 · Backend Development

Comparison of Transaction Message Implementations in ZuanZuan's Custom RocketMQ Version and the Open‑Source Community Version

This article analyzes why ZuanZuan built its own RocketMQ transaction‑message solution, compares the custom implementation with the community edition’s two‑phase commit approach, explains the underlying principles, sending flow, failure handling, and unknown‑state processing, and summarizes the trade‑offs of each design.

Distributed SystemsMessage QueueRocketMQ
0 likes · 10 min read
Comparison of Transaction Message Implementations in ZuanZuan's Custom RocketMQ Version and the Open‑Source Community Version
Top Architect
Top Architect
May 24, 2022 · Backend Development

Comprehensive Guide to Cache Optimization and Design Strategies

This article presents a comprehensive overview of cache optimization techniques, covering benefits and costs, update policies, granularity control, penetration and avalanche mitigation, hot‑key reconstruction, and distributed batch‑operation strategies, with practical examples using Redis and MySQL.

BackendDistributed SystemsPerformance
0 likes · 14 min read
Comprehensive Guide to Cache Optimization and Design Strategies
ByteFE
ByteFE
May 23, 2022 · Backend Development

Design and Implementation of ByteDance Wallet Asset Platform for the 2022 Spring Festival Activity Across Eight Apps

The article details the architecture, challenges, and solutions of ByteDance's wallet asset platform that unified reward issuance, display, and usage across eight applications during the 2022 Spring Festival, covering high‑traffic order processing, token‑based asynchronous settlement, budget control, stability mechanisms, and future evolution.

BackendDistributed SystemsMicroservices
0 likes · 29 min read
Design and Implementation of ByteDance Wallet Asset Platform for the 2022 Spring Festival Activity Across Eight Apps
IT Architects Alliance
IT Architects Alliance
May 21, 2022 · Backend Development

Cache Usage Techniques and Design Strategies

This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, and details practical design patterns such as update policies, granularity control, penetration, bottom‑hole, avalanche, and hot‑key optimizations for reliable high‑performance systems.

ConsistencyDistributed SystemsPerformance
0 likes · 13 min read
Cache Usage Techniques and Design Strategies
Bilibili Tech
Bilibili Tech
May 20, 2022 · Backend Development

Design and Implementation of Bilibili Object Storage Service (BOSS): Architecture, Topology, Metadata, Erasure Coding, and Scaling

The article chronicles Bilibili’s 13‑day development of BOSS, a custom object storage service, detailing how it replaces MySQL‑based routing and ID generation with replicated etcd or Raft KV stores, models metadata via protobuf, adopts erasure coding and a Bitcask‑style engine, and implements safe delete, replica repair, and horizontal scaling for a resilient large‑scale system.

Distributed Systemserasure codingmetadata design
0 likes · 28 min read
Design and Implementation of Bilibili Object Storage Service (BOSS): Architecture, Topology, Metadata, Erasure Coding, and Scaling
Qunar Tech Salon
Qunar Tech Salon
May 19, 2022 · Operations

Design and Optimization of a Large‑Scale Monitoring System at Qunar.com

This article describes the architecture, challenges, and performance optimizations of Qunar.com's Watcher monitoring platform, covering massive metric collection, master‑worker redesign, Graphite/Whisper storage enhancements, and future migration to Go‑based cloud‑native solutions.

CI/CDCloud NativeDistributed Systems
0 likes · 13 min read
Design and Optimization of a Large‑Scale Monitoring System at Qunar.com
vivo Internet Technology
vivo Internet Technology
May 18, 2022 · Backend Development

Kafka Cluster Fault Analysis: Root Cause and Cascading Failure Mechanism

A Kafka cluster at vivo suffered a total traffic drop across a resource group when a broker’s disk failed, because the default producer partitioner still hashed keys to the failed partition, exhausting client buffers and blocking all healthy partitions, prompting recommendations to avoid keys or use custom partitioners.

Distributed SystemsKafkaPerformance Optimization
0 likes · 9 min read
Kafka Cluster Fault Analysis: Root Cause and Cascading Failure Mechanism
DevOps
DevOps
May 18, 2022 · Operations

Understanding and Preventing Cascading Failures in Distributed Systems

The article explains how cascading failures arise from positive feedback loops in distributed systems, illustrates real‑world incidents such as the 2015 DynamoDB outage, outlines anti‑patterns like unlimited retries and unchecked load, and presents practical mitigation techniques including load‑shedding, circuit breakers, exponential back‑off, and controlled replication to improve system resilience.

Distributed SystemsResilienceSRE
0 likes · 19 min read
Understanding and Preventing Cascading Failures in Distributed Systems
DataFunSummit
DataFunSummit
May 15, 2022 · Databases

Design and Evolution of a Custom Storage Engine for IoT Device Metadata

This article presents a detailed case study of an IoT device metadata management platform, describing the business scenario, the evolution from a single‑node MySQL solution through sharded MySQL, HBase and Elasticsearch, to a self‑developed distributed storage engine that separates compute and storage, supports LSM, multi‑dimensional indexing, routing keys, and parallel scans to meet massive write‑read throughput and complex query requirements.

Big DataDistributed SystemsIoT
0 likes · 14 min read
Design and Evolution of a Custom Storage Engine for IoT Device Metadata
Top Architect
Top Architect
May 14, 2022 · Backend Development

Designing Microservices with Domain‑Driven Design, Bounded Contexts, and Event Storming

This article explains how microservice architecture leverages Domain‑Driven Design concepts such as bounded contexts and aggregates, uses context mapping and Event Storming to define service boundaries, and discusses communication patterns, eventual consistency, and Backend‑for‑Frontend design to build resilient, loosely‑coupled distributed systems.

Bounded ContextDistributed SystemsDomain-Driven Design
0 likes · 18 min read
Designing Microservices with Domain‑Driven Design, Bounded Contexts, and Event Storming
Top Architect
Top Architect
May 13, 2022 · Backend Development

Design and Implementation of Delayed Message Queues in Distributed Systems

This article surveys common delayed message implementations—including external storage, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar, and QMQ—analyzing their architectures, advantages, drawbacks, and practical considerations for building reliable distributed asynchronous messaging systems.

Distributed SystemsPulsarQMQ
0 likes · 13 min read
Design and Implementation of Delayed Message Queues in Distributed Systems
Zuoyebang Tech Team
Zuoyebang Tech Team
May 13, 2022 · Operations

Build a Scalable, Cost‑Effective Log Retrieval System Without Elasticsearch

This article explains how to design a high‑performance, low‑cost log retrieval architecture that avoids Elasticsearch by partitioning logs into time‑based chunks, indexing only metadata, using multi‑tier storage (local, remote, archive), and orchestrating queries through GD‑Search, Local‑Search, Remote‑Search and Log‑Manager components.

Distributed SystemsStorage Optimizationcost efficiency
0 likes · 14 min read
Build a Scalable, Cost‑Effective Log Retrieval System Without Elasticsearch
dbaplus Community
dbaplus Community
May 12, 2022 · Big Data

How Bilibili Scaled Presto on Hadoop: Architecture, Optimizations, and Performance Gains

This article details Bilibili's end‑to‑end Presto on Hadoop architecture, covering the multi‑engine SQL stack, dispatcher routing, cluster scale, stability enhancements like coordinator HA and real‑time punish, query limits, Hive UDF compatibility, insert‑overwrite support, Alluxio caching, multi‑datacenter routing, query result caching, Raptorx local cache, JDK upgrades, dynamic filtering, and future roadmap, illustrating how these innovations boosted query throughput and reduced latency.

Big DataCluster ManagementDistributed Systems
0 likes · 32 min read
How Bilibili Scaled Presto on Hadoop: Architecture, Optimizations, and Performance Gains
Architect's Alchemy Furnace
Architect's Alchemy Furnace
May 10, 2022 · Operations

How to Build Truly High‑Availability Systems: Redundancy, Failover, and Layered Architecture

High availability (HA) is essential for distributed systems, requiring redundancy and automatic failover across each architectural layer—from client to proxy, gateway, business logic, cache, and storage—to minimize downtime, achieve desired “nines” of uptime, and prevent cascading failures such as service snowballing.

Distributed SystemsSystem Architecturefailover
0 likes · 14 min read
How to Build Truly High‑Availability Systems: Redundancy, Failover, and Layered Architecture
Sanyou's Java Diary
Sanyou's Java Diary
May 8, 2022 · Backend Development

How Nacos’s Distro Protocol Ensures High Availability with AP Consistency

This article explains Nacos’s Distro consistency protocol, detailing its design principles, asynchronous replication, periodic synchronization, new‑node data loading, and local read mechanisms, and shows how these mechanisms together provide high‑availability AP consistency for service registration in a distributed cluster.

AP ConsistencyDistributed SystemsDistro Protocol
0 likes · 14 min read
How Nacos’s Distro Protocol Ensures High Availability with AP Consistency
Wukong Talks Architecture
Wukong Talks Architecture
May 5, 2022 · Backend Development

Deep Dive into Nacos Distro Consistency Protocol: Design, Mechanisms, and Source Code Analysis

This article explains the design principles, six core mechanisms, asynchronous replication, periodic synchronization, new‑node sync, and local read strategy of Nacos's Distro consistency protocol, illustrating how AP/CP choices and the JRaft protocol ensure high availability in a distributed service registry.

APConsistencyDistributed Systems
0 likes · 13 min read
Deep Dive into Nacos Distro Consistency Protocol: Design, Mechanisms, and Source Code Analysis
IT Architects Alliance
IT Architects Alliance
Apr 29, 2022 · R&D Management

30 Essential Architecture Principles Every Software Architect Should Follow

This article presents thirty practical software‑architecture principles—from keeping designs simple and avoiding unnecessary features to mastering concurrency, distributed systems, and user experience—providing a comprehensive guide that helps architects make informed, ROI‑driven decisions while fostering scalable, maintainable solutions.

Distributed SystemsMVPR&D management
0 likes · 11 min read
30 Essential Architecture Principles Every Software Architect Should Follow
Tencent Cloud Developer
Tencent Cloud Developer
Apr 28, 2022 · Operations

Mastering ZooKeeper: Installation, Znode Model, Watchers, and Leader Election Explained

This comprehensive guide walks you through ZooKeeper's role in distributed systems, detailed installation steps, Znode data structures, watcher mechanisms, ZAB protocol operations, and the FastLeaderElection algorithm, providing practical commands and configuration examples for building reliable coordination services.

Coordination ServiceDistributed SystemsInstallation
0 likes · 32 min read
Mastering ZooKeeper: Installation, Znode Model, Watchers, and Leader Election Explained
Cloud Native Technology Community
Cloud Native Technology Community
Apr 26, 2022 · Backend Development

Rapid Event Notification System (RENO) at Netflix: Design, Architecture, and Lessons Learned

Netflix built the Rapid Event Notification (RENO) system to deliver real‑time, scalable, and prioritized notifications across millions of devices, handling diverse use cases such as watch activity, personalization updates, plan changes, and diagnostics while managing high request‑per‑second loads through a hybrid push‑pull model and targeted delivery.

Backend ArchitectureDistributed SystemsNetflix
0 likes · 13 min read
Rapid Event Notification System (RENO) at Netflix: Design, Architecture, and Lessons Learned
Volcano Engine Developer Services
Volcano Engine Developer Services
Apr 26, 2022 · Operations

How Volcano Engine’s TLS Transforms Log Management for Kubernetes at Scale

This article explains the challenges of traditional open‑source log collection in cloud‑native environments, describes Volcano Engine’s unified TLS architecture, its centralized configuration, CRD‑based deployment, and showcases real‑world case studies that demonstrate improved availability, efficiency, and scalability.

Cloud NativeDistributed SystemsKubernetes
0 likes · 15 min read
How Volcano Engine’s TLS Transforms Log Management for Kubernetes at Scale
macrozheng
macrozheng
Apr 26, 2022 · Backend Development

Service Registry Showdown: Zookeeper, Eureka, Nacos, Consul & ETCD

This article examines five popular service registries—Zookeeper, Eureka, Nacos, Consul, and ETCD—explaining their core concepts, architecture, CAP trade‑offs, health‑check mechanisms, multi‑data‑center support, and provides guidance on selecting the most suitable registry for different technology stacks and availability requirements.

CAP theoremDistributed SystemsMicroservices
0 likes · 25 min read
Service Registry Showdown: Zookeeper, Eureka, Nacos, Consul & ETCD
Alibaba Terminal Technology
Alibaba Terminal Technology
Apr 25, 2022 · Backend Development

How RTMS Revolutionizes Real‑Time Messaging for Massive Interactive Apps

RTMS (Real Time Message Service) is a frame‑synchronization‑based real‑time communication solution that offloads logic from the server, uses in‑memory processing, and employs decentralized, non‑persistent, publish‑subscribe routing to dramatically improve latency, scalability, and interactivity for high‑frequency multi‑user scenarios.

Backend ArchitectureDecentralizationDistributed Systems
0 likes · 10 min read
How RTMS Revolutionizes Real‑Time Messaging for Massive Interactive Apps
IT Architects Alliance
IT Architects Alliance
Apr 24, 2022 · Backend Development

Distributed Locks and Idempotency: Principles, Implementations, and the Cerberus Solution

This article explains the challenges of mutual exclusion and idempotency in distributed systems, reviews Java concurrency primitives, compares common distributed lock implementations such as Zookeeper, Redis, and Tair, and introduces Cerberus and GTIS as robust solutions for high‑availability and repeatable operations.

CerberusDistributed SystemsGTIS
0 likes · 31 min read
Distributed Locks and Idempotency: Principles, Implementations, and the Cerberus Solution
Top Architect
Top Architect
Apr 23, 2022 · Backend Development

Common Implementation Schemes for Delayed Messages in Distributed Systems

This article examines various approaches to implementing delayed (scheduled) messages in distributed message queue systems, comparing external storage, RocksDB, Redis, and open‑source MQ solutions, and discusses their advantages, drawbacks, and practical considerations.

ArchitectureBackendDistributed Systems
0 likes · 13 min read
Common Implementation Schemes for Delayed Messages in Distributed Systems
Code Ape Tech Column
Code Ape Tech Column
Apr 23, 2022 · Big Data

Kafka Fundamentals: Architecture, Replication, Partitioning, and Performance

This article provides a comprehensive overview of Kafka, covering its role as a message middleware, core concepts, architecture, replication management, partition handling, producer sending modes, partition assignment strategies, load balancing, reliability mechanisms, consumer models, controller election, and factors that affect its high throughput and potential message loss scenarios.

Distributed SystemsKafkaMessage Queue
0 likes · 29 min read
Kafka Fundamentals: Architecture, Replication, Partitioning, and Performance
21CTO
21CTO
Apr 22, 2022 · Backend Development

From Single Server to Cloud‑Native: How Taobao Scaled to Millions of Users

This article traces Taobao’s architectural evolution—from a single‑machine setup to distributed clusters, caching layers, load‑balancing proxies, database sharding, microservices, ESB, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles that enable scaling from hundreds to tens of millions of concurrent users.

ArchitectureDistributed SystemsMicroservices
0 likes · 22 min read
From Single Server to Cloud‑Native: How Taobao Scaled to Millions of Users
Architect
Architect
Apr 20, 2022 · Operations

Load Balancing in High‑Concurrency Scenarios: Alibaba Double 11, 12306 Railway, WeChat Red Packets, and Douyin Spring Festival Gala

This article examines real‑world load‑balancing implementations for ultra‑high traffic cases such as Alibaba's Double 11 shopping festival, China's 12306 railway ticketing system, WeChat's red‑packet service, and Douyin's Spring Festival gala, highlighting architectural principles, DPDK usage, ECMP routing, session synchronization, SET‑based sharding, and service‑mesh techniques.

DPDKDistributed SystemsMicroservices
0 likes · 12 min read
Load Balancing in High‑Concurrency Scenarios: Alibaba Double 11, 12306 Railway, WeChat Red Packets, and Douyin Spring Festival Gala
IT Xianyu
IT Xianyu
Apr 20, 2022 · Fundamentals

Designing Scalable Systems for Billions of Users: From a Single Server to Distributed Architecture

This article explains how to evolve a simple single‑server web application into a highly available, horizontally and vertically scalable system for billions of users by covering DNS, vertical and horizontal scaling, load balancing, database replication, sharding, denormalization, SQL/NoSQL choices, stateless design, caching, CDN and global deployment.

Database ReplicationDistributed SystemsScalability
0 likes · 18 min read
Designing Scalable Systems for Billions of Users: From a Single Server to Distributed Architecture
JD Tech
JD Tech
Apr 14, 2022 · Backend Development

JD.com Flash Sale Product Pool Expansion: Architecture Upgrade and Performance Optimization

This article details how JD.com tackled rapid growth of its flash‑sale product pool by analyzing JVM GC bottlenecks, redesigning the system architecture, introducing dual‑cache bucket updates, local LRU caching, Bloom filters, and service separation, ultimately achieving significant performance and stability improvements for large‑scale promotions.

Distributed SystemsGC optimizationJVM
0 likes · 12 min read
JD.com Flash Sale Product Pool Expansion: Architecture Upgrade and Performance Optimization
Architect
Architect
Apr 14, 2022 · Backend Development

Understanding Idempotent Design: Concepts, Scenarios, and Eight Practical Implementation Strategies

This article explains the mathematical and computer‑science definition of idempotency, why it is essential for reliable distributed services, how to handle timeout scenarios, and presents eight concrete design patterns—including unique IDs, database constraints, token mechanisms, optimistic/pessimistic locks, and distributed locks—along with code examples and HTTP method analysis.

Distributed SystemsHTTPbackend-development
0 likes · 18 min read
Understanding Idempotent Design: Concepts, Scenarios, and Eight Practical Implementation Strategies
macrozheng
macrozheng
Apr 14, 2022 · Operations

Mastering High Availability: 4 Essential Design Techniques for Scalable Systems

This article outlines the core high‑availability techniques—system splitting, decoupling, asynchronous processing, retry, compensation, backup, multi‑active strategies, isolation, rate limiting, circuit breaking, and degradation—providing practical guidance for designing resilient, scalable backend architectures in large‑scale internet applications.

Distributed SystemsMicroservicesSystem Design
0 likes · 13 min read
Mastering High Availability: 4 Essential Design Techniques for Scalable Systems
Architect's Journey
Architect's Journey
Apr 13, 2022 · Fundamentals

Is Classifying Distributed Systems as CP or AP a False Dichotomy?

The article revisits the CAP theorem, explains linearizable consistency and strict availability, demonstrates with concrete data‑center examples why the CP/AP split is often misleading, and argues that latency concerns and broader failure modes make the binary classification of distributed systems impractical.

AvailabilityCAP theoremCP vs AP
0 likes · 10 min read
Is Classifying Distributed Systems as CP or AP a False Dichotomy?
DataFunTalk
DataFunTalk
Apr 12, 2022 · Big Data

Kuaishou Big Data Task Scheduling System: Architecture, Challenges, and Key Technologies

This article presents Kuaishou's large‑scale big‑data task scheduling system, describing its evolution from Airflow to the self‑developed Kwaiflow, the performance and reliability challenges of handling hundreds of thousands of tasks, and the design decisions that achieve low latency, high availability, and strong open capabilities.

Distributed SystemsKuaishouKwaiflow
0 likes · 22 min read
Kuaishou Big Data Task Scheduling System: Architecture, Challenges, and Key Technologies
Code Ape Tech Column
Code Ape Tech Column
Apr 10, 2022 · Backend Development

Implementing Distributed WebSocket Clusters with Spring Cloud, Consistent Hashing, and Gateway

This article explores practical approaches for building a distributed WebSocket cluster in a Spring Cloud environment, covering session handling, Netty versus Spring WebSocket implementations, session broadcasting, consistent‑hash routing, gateway configuration, Ribbon limitations, and provides code examples for each solution.

BackendDistributed SystemsSpring Cloud
0 likes · 17 min read
Implementing Distributed WebSocket Clusters with Spring Cloud, Consistent Hashing, and Gateway
IT Architects Alliance
IT Architects Alliance
Apr 10, 2022 · Backend Development

Understanding Elasticsearch: Core Concepts, Architecture, and Performance Tips

This article provides a comprehensive overview of Elasticsearch, covering data types, Lucene fundamentals, cluster discovery, node roles, shard and replica management, mapping, installation, health monitoring, indexing mechanics, storage strategies, refresh and translog processes, segment merging, and practical performance optimizations for production deployments.

Distributed SystemsElasticsearchindexing
0 likes · 39 min read
Understanding Elasticsearch: Core Concepts, Architecture, and Performance Tips
JD Tech
JD Tech
Apr 8, 2022 · Big Data

Designing a High‑Throughput Log Collection System with ClickHouse, UDP and Compression

The article analyses the massive cost and performance challenges of traditional log‑storage pipelines at JD.com, then proposes a streamlined architecture that eliminates disk and MQ stages, uses in‑memory buffering, UDP transport, Snappy/ZSTD compression, and ClickHouse storage to achieve multi‑gigabyte per‑second throughput with over 70% hardware cost reduction.

ClickHouseDistributed SystemsHigh Throughput
0 likes · 15 min read
Designing a High‑Throughput Log Collection System with ClickHouse, UDP and Compression
IT Architects Alliance
IT Architects Alliance
Apr 7, 2022 · Fundamentals

30 Architectural Principles for Software Engineers

This article presents thirty concise architectural principles covering simplicity, YAGNI, iterative development, testing, ROI, user focus, modular design, configuration, server concurrency, distributed system challenges, and user experience, offering practical guidance for engineers to build scalable, maintainable software systems.

Distributed SystemsEngineeringSoftware Architecture
0 likes · 12 min read
30 Architectural Principles for Software Engineers
Architects' Tech Alliance
Architects' Tech Alliance
Apr 2, 2022 · Industry Insights

How Financial Institutions Secure Database Continuity: Disaster Recovery Strategies & Market Trends

This article examines the critical role of databases in finance, defines disaster recovery and backup concepts, outlines industry requirements and regulations, analyzes market growth, and compares distributed database disaster‑recovery architectures such as single‑center, city‑level mutual backup, active‑active, and two‑site three‑center solutions.

BackupDistributed SystemsFinancial Services
0 likes · 15 min read
How Financial Institutions Secure Database Continuity: Disaster Recovery Strategies & Market Trends
Top Architect
Top Architect
Mar 31, 2022 · Backend Development

Meituan Instant Logistics: Distributed System Architecture Evolution and Challenges

The article details Meituan's five‑year journey building a high‑concurrency, AI‑enhanced instant logistics platform, describing its distributed architecture, scalability and reliability practices, fault‑tolerance mechanisms, and future challenges in microservice and unit‑based operations.

AIArchitectureDistributed Systems
0 likes · 10 min read
Meituan Instant Logistics: Distributed System Architecture Evolution and Challenges
Java Interview Crash Guide
Java Interview Crash Guide
Mar 31, 2022 · Backend Development

How We Achieved 20k TPS High‑Availability for a Billion‑User Membership System

This article details the design and implementation of a highly available, high‑performance membership system serving billions of users, covering Elasticsearch dual‑center clusters, traffic‑isolated architectures, deep ES optimizations, Redis caching with distributed locks, dual‑center MySQL partitioning, migration strategies, abnormal account handling, and future fine‑grained flow‑control and degradation policies.

Distributed SystemsElasticsearchMySQL
0 likes · 20 min read
How We Achieved 20k TPS High‑Availability for a Billion‑User Membership System
Top Architect
Top Architect
Mar 30, 2022 · Backend Development

Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations

The article discusses how to achieve interface idempotency using unique business identifiers or token mechanisms, then explores distributed rate limiting by outlining its dimensions, common algorithms such as token bucket and leaky bucket, and provides concrete implementation examples with Guava RateLimiter, Nginx, and Redis‑Lua scripts.

BackendDistributed SystemsIdempotency
0 likes · 20 min read
Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations
High Availability Architecture
High Availability Architecture
Mar 29, 2022 · Fundamentals

Abstract Paxos: Unifying Paxos and Raft through Formal Derivation of Distributed Consensus

This article presents abstract‑paxos, a unified framework that derives Paxos and Raft from first principles, defines information certainty, quorum, and a total order on states using commit_index, and details a two‑phase protocol, member‑change handling, and how the model maps to classic Paxos and Raft implementations.

ConsensusDistributed SystemsPaxos
0 likes · 25 min read
Abstract Paxos: Unifying Paxos and Raft through Formal Derivation of Distributed Consensus
IT Architects Alliance
IT Architects Alliance
Mar 28, 2022 · Fundamentals

Evolution and Fundamentals of Storage Systems: From Single-Node to Cloud‑Native

This article outlines the historical development of storage systems—from single-node and centralized architectures to distributed, cloud, and cloud‑native solutions—detailing storage types (block, file, object), data models, system components, and key design principles for modern storage infrastructures.

Data ModelsDistributed Systemsblock storage
0 likes · 7 min read
Evolution and Fundamentals of Storage Systems: From Single-Node to Cloud‑Native
IT Architects Alliance
IT Architects Alliance
Mar 27, 2022 · Backend Development

Simulating a 10‑Billion Red‑Envelope System with Go: From 3K to 6K QPS

This article details a step‑by‑step engineering experiment that reproduces a high‑throughput "red‑envelope" service, outlining the required hardware, software stack, load‑generation logic, monitoring setup, and performance results for handling up to 6 000 QPS on a 100‑million‑user scale.

BackendDistributed SystemsGo
0 likes · 21 min read
Simulating a 10‑Billion Red‑Envelope System with Go: From 3K to 6K QPS
IT Architects Alliance
IT Architects Alliance
Mar 27, 2022 · Backend Development

From a Simple MVP Monolith to a Complex Distributed Architecture: Taobao Case Study

This article walks through the step‑by‑step evolution of a basic single‑server e‑commerce system into a large‑scale, distributed architecture, explaining core concepts, each architectural upgrade, the technologies involved, and key design principles for building scalable, high‑availability services.

ArchitectureCloud ComputingDistributed Systems
0 likes · 20 min read
From a Simple MVP Monolith to a Complex Distributed Architecture: Taobao Case Study
Architects' Tech Alliance
Architects' Tech Alliance
Mar 26, 2022 · Fundamentals

A Comprehensive Overview of Storage Development History, Types, and Models

This article provides a detailed overview of the evolution of storage systems—from single‑node to cloud‑native—covering fundamental concepts, data classifications, storage types such as block, file, and object, and examples like Rook and MinIO, aimed at beginners seeking a macro understanding of storage architecture.

Data ModelsDistributed Systemsblock storage
0 likes · 8 min read
A Comprehensive Overview of Storage Development History, Types, and Models
Java Backend Technology
Java Backend Technology
Mar 26, 2022 · Backend Development

XXL-JOB Mastery: A Step-by-Step Spring Boot Guide to Distributed Scheduling

This tutorial walks you through installing and configuring the open‑source XXL‑JOB scheduler, comparing it with ElasticJob, setting up the admin console, creating a Spring Boot project, adding the necessary dependencies, configuring database and logging, and implementing scheduled tasks using Bean, Method, and GLUE modes, complete with code examples and screenshots.

Distributed SystemsXXL-JOBtask scheduling
0 likes · 15 min read
XXL-JOB Mastery: A Step-by-Step Spring Boot Guide to Distributed Scheduling
IT Services Circle
IT Services Circle
Mar 25, 2022 · Fundamentals

Consistent Hashing Algorithm: Principles, Advantages, and Applications

Consistent hashing maps both servers and keys onto a virtual hash ring, allowing keys to be assigned to the nearest clockwise server, which minimizes data movement during node addition or removal, improves load distribution with virtual nodes, and is widely used in distributed caching and load balancing systems.

CacheDistributed Systemsconsistent hashing
0 likes · 11 min read
Consistent Hashing Algorithm: Principles, Advantages, and Applications
Top Architect
Top Architect
Mar 25, 2022 · Backend Development

Design and Architecture of Baidu Transaction Middleware Order System

This article explains the business model, capabilities, service types, order lifecycle, and detailed architectural evolution of Baidu's transaction middle‑platform order system, covering instruction orchestration, performance optimizations such as caching, async execution, ThreadLocal handling, and database sharding for high‑throughput scenarios.

Backend ArchitectureDistributed Systemsdatabase sharding
0 likes · 15 min read
Design and Architecture of Baidu Transaction Middleware Order System