BestHub
Sign in
Tagged articles

distributed systems

2274 articles · Page 12 of 23
Top Architect
Top Architect
Nov 5, 2021 · Backend Development

High‑Concurrency Architecture Design and Best Practices

This article presents a comprehensive guide to designing high‑concurrency systems, covering server architecture, load balancing, database clustering, caching strategies, message‑queue based async processing, static data offloading, service‑oriented design, redundancy, automation, and practical implementation examples for large‑scale web applications.

High ConcurrencyMessage Queuebackend architecture
0 likes · 18 min read
High‑Concurrency Architecture Design and Best Practices
IT Architects Alliance
IT Architects Alliance
Nov 2, 2021 · Backend Development

Building a Scalable Distributed WebSocket Cluster Using Spring Cloud & Consistent Hashing

This article analyzes the challenges of multi‑user WebSocket communication in a clustered environment, compares Netty and Spring WebSocket implementations, and presents two practical solutions—session broadcast and a consistent‑hashing based routing scheme—complete with code samples, gateway configuration, and load‑balancing considerations.

NettySpring CloudWebSocket
0 likes · 18 min read
Building a Scalable Distributed WebSocket Cluster Using Spring Cloud & Consistent Hashing
21CTO
21CTO
Oct 31, 2021 · Backend Development

How to Build a Distributed WebSocket Cluster with Spring Cloud, Eureka, and Consistent Hashing

This article explores practical approaches for enabling multi‑user communication in a distributed WebSocket cluster, covering session handling challenges, architecture design, technology stack choices, Netty versus Spring WebSocket implementations, consistent‑hashing load balancing, and detailed code examples for Spring Cloud Gateway and Ribbon integration.

JavaSpring BootSpring Cloud
0 likes · 19 min read
How to Build a Distributed WebSocket Cluster with Spring Cloud, Eureka, and Consistent Hashing
Architecture Digest
Architecture Digest
Oct 31, 2021 · Backend Development

Why Resource Isolation Matters and Common Isolation Techniques in Distributed Systems

The article explains the importance of isolating resources such as CPU, network, and disk in distributed architectures, describes thread, process, cluster, data‑read/write, static, and crawler isolation methods, and provides concrete code examples and best‑practice recommendations for backend developers.

Resource IsolationThread Isolationdistributed systems
0 likes · 13 min read
Why Resource Isolation Matters and Common Isolation Techniques in Distributed Systems
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 29, 2021 · Cloud Native

RocketMQ 5.0 Overview: A Cloud‑Native Messaging, Event and Stream Fusion Platform

This article reviews the evolution of RocketMQ from its early MetaQ roots through the 4.x releases, explains the motivations behind RocketMQ 5.0, and details its cloud‑native architecture, lightweight SDK, storage‑compute separation, POP consumption model, elastic scaling, and the upcoming RocketMQ Streams framework.

Message QueueRocketMQdistributed systems
0 likes · 18 min read
RocketMQ 5.0 Overview: A Cloud‑Native Messaging, Event and Stream Fusion Platform
Efficient Ops
Efficient Ops
Oct 28, 2021 · Operations

Why Geo‑Active‑Active Architecture Is the Key to Ultra‑High System Availability

This article explains the principles behind geo‑active‑active (multi‑active) architectures, covering system availability metrics, redundancy strategies from single‑node backups to same‑city and cross‑city active‑active deployments, data‑sync challenges, routing and sharding techniques, and how these designs dramatically improve reliability and scalability.

disaster recoverydistributed systemsgeo-active-active
0 likes · 37 min read
Why Geo‑Active‑Active Architecture Is the Key to Ultra‑High System Availability
IT Architects Alliance
IT Architects Alliance
Oct 27, 2021 · Backend Development

Common Mistakes When Building Microservices and Lessons Learned

The article reviews the most frequent errors encountered while adopting microservice architecture—excessive customization, uncontrolled complexity, and vague definitions—illustrating each with real‑world experiences, a saga implementation using Redis streams and Go, and practical advice to avoid similar pitfalls.

GoRedisSAGA
0 likes · 6 min read
Common Mistakes When Building Microservices and Lessons Learned
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 26, 2021 · Fundamentals

Jepsen Uncovered: A Practical Guide to Linearizability Testing

This article explains the fundamentals of Jepsen testing, compares it with TLA+, describes its architecture and workflow, illustrates how to apply Jepsen for linearizability verification of distributed systems such as locks, and offers practical guidance on integrating Jepsen or building custom testing frameworks.

ConsistencyJepsenLinearizability
0 likes · 17 min read
Jepsen Uncovered: A Practical Guide to Linearizability Testing
Laravel Tech Community
Laravel Tech Community
Oct 26, 2021 · Databases

Understanding Ant Financial’s LDC Architecture: Unitization, CAP Analysis, and OceanBase Design

The article explains how Ant Financial scales Double‑11 payment traffic to hundreds of thousands of TPS by employing logical data centers (LDC), unit‑based system design (RZone, GZone, CZone), database sharding, CAP theorem analysis, Paxos‑based consensus, and the OceanBase distributed database, while also detailing disaster‑recovery and traffic‑shifting mechanisms.

CAP theoremHigh TPSOceanBase
0 likes · 35 min read
Understanding Ant Financial’s LDC Architecture: Unitization, CAP Analysis, and OceanBase Design
IT Architects Alliance
IT Architects Alliance
Oct 21, 2021 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Real‑World Implementations

This article explains why rate limiting is essential for system stability, compares circuit breaking, service degradation, delayed processing, and privileged handling, details counter, leaky‑bucket, and token‑bucket algorithms, and provides concrete Java, Guava, and Nginx‑Lua code examples for practical deployment.

GuavaJavacircuit breaker
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Strategies, and Real‑World Implementations
dbaplus Community
dbaplus Community
Oct 20, 2021 · Big Data

How JD Achieves ClickHouse High‑Availability for Billion‑Scale OLAP

JD's OLAP platform runs on ClickHouse and Doris across 3,000 servers, handling billions of daily queries and petabytes of data, and this article details the selection criteria, cluster deployment models, high‑availability architecture, operational challenges, and future roadmap.

ClickHouseCluster DeploymentJD.com
0 likes · 21 min read
How JD Achieves ClickHouse High‑Availability for Billion‑Scale OLAP
Java Architect Essentials
Java Architect Essentials
Oct 18, 2021 · Fundamentals

Fundamentals of Distributed Systems: Models, Replication, Consistency, and Protocols

This article introduces core concepts of distributed systems, including node and replica models, various consistency levels, data distribution strategies, lease and quorum mechanisms, replica control protocols such as primary‑secondary, two‑phase commit, MVCC, Paxos, and the CAP theorem, providing a comprehensive overview for architects.

CAP theoremConsensusConsistency
0 likes · 54 min read
Fundamentals of Distributed Systems: Models, Replication, Consistency, and Protocols
MaGe Linux Operations
MaGe Linux Operations
Oct 16, 2021 · Operations

Why Does One Kafka Broker Failure Halt All Consumers? HA & Replication Explained

The article examines Kafka’s high‑availability mechanisms, detailing its multi‑replica design, ISR synchronization, leader election, and the critical role of the __consumer_offset topic, and explains why a single broker outage can render the entire cluster unusable unless replication factors are properly configured.

Consumer offsetKafkaReplication
0 likes · 10 min read
Why Does One Kafka Broker Failure Halt All Consumers? HA & Replication Explained
Big Data Technology Architecture
Big Data Technology Architecture
Oct 15, 2021 · Backend Development

Key Concepts and Internal Mechanisms of Apache Kafka

This article explains Kafka's internal topics, preferred replicas, partition assignment processes, log directory layout, index files, offset and timestamp lookup, log retention and compaction policies, storage architecture, delayed operations, controller role, legacy consumer design flaws, rebalance workflow, and producer idempotence, providing a comprehensive overview of Kafka's backend architecture.

Consumer OffsetsIdempotenceLog Retention
0 likes · 16 min read
Key Concepts and Internal Mechanisms of Apache Kafka
Ctrip Technology
Ctrip Technology
Oct 14, 2021 · Backend Development

Optimizing a High‑Concurrency Ticket Reservation System for the "Travel with Love" Campaign

This article presents a comprehensive case study of the technical challenges and optimization strategies—including traffic surges, cache penetration, cache breakdown, limit‑purchase handling, and inventory deduction—encountered during a large‑scale ticket reservation event, and demonstrates how systematic backend improvements achieved over 50% performance gains and 98% cache hit rate.

CachingHigh Concurrencybackend optimization
0 likes · 13 min read
Optimizing a High‑Concurrency Ticket Reservation System for the "Travel with Love" Campaign
Java Interview Crash Guide
Java Interview Crash Guide
Oct 13, 2021 · Backend Development

How to Achieve Exactly-Once Message Processing with RocketMQ Deduplication

Message middleware guarantees at-least-once delivery, but duplicate deliveries can cause issues; this article explains RocketMQ’s three duplication scenarios, explores simple and advanced deduplication strategies—including database-transaction and non-transactional approaches using Redis—and provides practical code samples for implementing reliable exactly-once processing.

Exactly-OnceMessage QueueRocketMQ
0 likes · 21 min read
How to Achieve Exactly-Once Message Processing with RocketMQ Deduplication
IT Architects Alliance
IT Architects Alliance
Oct 12, 2021 · Backend Development

Technical Summary of Large-Scale Distributed Website Architecture

This article provides a comprehensive overview of large‑scale distributed website architecture, covering its characteristics, design goals, architectural patterns, performance, high‑availability, scalability, extensibility, security, agility, evolution stages, and practical implementation techniques such as caching, load balancing, database sharding, service‑orientation and message queues.

CachingDatabase Clusteringdistributed systems
0 likes · 23 min read
Technical Summary of Large-Scale Distributed Website Architecture
ByteDance ADFE Team
ByteDance ADFE Team
Oct 12, 2021 · Fundamentals

Designing for Failure: Principles, Organizational Practices, and Technical Solutions

This article examines why failure is inevitable in software systems, proposes a mindset of failure‑oriented design, outlines organizational roles and processes to mitigate incidents, and presents concrete technical techniques such as distributed locking and traffic shaping to build resilient, high‑availability services.

Failure Designdistributed systemshigh availability
0 likes · 25 min read
Designing for Failure: Principles, Organizational Practices, and Technical Solutions
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 11, 2021 · Fundamentals

Can Joint Consensus Member Changes Be Simplified to a Single Step?

This article examines the challenges of Raft’s two‑stage Joint Consensus member changes, explores single‑step alternatives, analyzes ZooKeeper’s approach, and proposes improvements that combine safety with reduced log overhead, offering practical insights for distributed system engineers seeking more efficient reconfiguration methods.

ConsensusRaftZooKeeper
0 likes · 15 min read
Can Joint Consensus Member Changes Be Simplified to a Single Step?
Java Architect Essentials
Java Architect Essentials
Oct 11, 2021 · Backend Development

Evolution of Large-Scale Website Architecture and Key Design Patterns

The article outlines the characteristics of high‑traffic websites and traces the architectural evolution from a single‑server model to distributed, cache‑enabled, load‑balanced, and service‑oriented designs, highlighting techniques such as clustering, read/write splitting, CDN, NoSQL, and business micro‑services.

Cachingdistributed systemsload balancing
0 likes · 6 min read
Evolution of Large-Scale Website Architecture and Key Design Patterns
Baidu Geek Talk
Baidu Geek Talk
Oct 11, 2021 · Backend Development

Baidu Search Closed-Door Technical Symposium

The Baidu Search Closed‑Door Technical Symposium, the first core technical forum hosted by Baidu’s Search Architecture Department, brings senior engineers and junior backend developers together to discuss semantic retrieval, data‑driven big‑data processing, and vertical search offline architecture, while offering limited‑capacity sessions, networking gifts, and travel subsidies.

Baidu SearchCloud-Native Architecturebackend development
0 likes · 6 min read
Baidu Search Closed-Door Technical Symposium
21CTO
21CTO
Oct 9, 2021 · Backend Development

ElasticSearch Near Real-Time Search: Immutable Indexes, Segments, and Translog

This article explores how ElasticSearch delivers near real‑time search by leveraging immutable inverted indexes, segment merging, shard distribution, and a write‑ahead translog, detailing the challenges of persistence, disk I/O, and data loss prevention in a distributed environment.

Near Real-Time SearchSegment Mergingdistributed systems
0 likes · 9 min read
ElasticSearch Near Real-Time Search: Immutable Indexes, Segments, and Translog
High Availability Architecture
High Availability Architecture
Oct 9, 2021 · Databases

Building a High‑Performance Cloud‑Native KV Storage System at Baidu

This article describes Baidu's design and implementation of a cloud‑native, high‑performance KV storage platform—UNDB—covering the performance and cloud‑native challenges, engine optimizations, dynamic management, multi‑model architecture, and the resulting cost and reliability improvements for massive search and feed workloads.

BaiduKV storageNoSQL
0 likes · 19 min read
Building a High‑Performance Cloud‑Native KV Storage System at Baidu
Selected Java Interview Questions
Selected Java Interview Questions
Oct 9, 2021 · Backend Development

RocketMQ vs Kafka: Detailed Feature, Performance, and Reliability Comparison

This article provides a comprehensive comparison between RocketMQ and Kafka, covering data reliability, performance, queue capacity, real‑time delivery, retry mechanisms, ordering guarantees, scheduled messages, transactional support, query capabilities, message tracing, consumer parallelism, filtering, and commercial backing, helping engineers choose the right messaging middleware for their workloads.

KafkaMessage QueueRocketMQ
0 likes · 11 min read
RocketMQ vs Kafka: Detailed Feature, Performance, and Reliability Comparison
ITPUB
ITPUB
Oct 8, 2021 · Cloud Native

How China’s Postal Savings Bank Built a Distributed Core System with OpenGauss and Kunpeng

The article examines how Postal Savings Bank of China tackled legacy core banking limitations by designing a distributed, cloud‑native core system using openGauss, Kunpeng hardware, microservices, and DevOps, detailing the architecture, deployment process, performance gains, and industry implications.

Kunpengcore bankingdistributed systems
0 likes · 10 min read
How China’s Postal Savings Bank Built a Distributed Core System with OpenGauss and Kunpeng
Java Architect Essentials
Java Architect Essentials
Oct 7, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Types, and Evolution

This article explains the essence of software architecture, defining systems, subsystems, modules, components, frameworks, and various architectural layers such as business, application, data, code, technical, and deployment, and discusses architectural evolution from monolithic to distributed and microservice designs, including common pitfalls and recommended reading.

architecture patternsdistributed systemssoftware architecture
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Types, and Evolution
Code Ape Tech Column
Code Ape Tech Column
Oct 6, 2021 · Operations

An Overview of Four Popular Distributed Message Queue Middleware: Kafka, ActiveMQ, RabbitMQ, and RocketMQ

This article introduces the concepts, core features, deployment environments, architectures, high‑availability solutions, advantages and disadvantages of four widely used open‑source distributed message queue systems—Kafka, ActiveMQ, RabbitMQ, and RocketMQ—and provides a comparative analysis to help practitioners choose the right middleware for their distributed applications.

ActiveMQKafkaMessage Queue
0 likes · 37 min read
An Overview of Four Popular Distributed Message Queue Middleware: Kafka, ActiveMQ, RabbitMQ, and RocketMQ
Top Architect
Top Architect
Oct 4, 2021 · Backend Development

Mutual Exclusion and Idempotency in Distributed Systems: Problems, Principles, and Solutions

This article examines the challenges of mutual exclusion and idempotency in distributed environments, explains their underlying principles, compares multithread and multiprocess approaches, and presents practical distributed‑lock implementations such as Zookeeper, Redis, Tair, and the Cerberus framework, as well as the GTIS solution for idempotency.

CerberusGTISIdempotency
0 likes · 32 min read
Mutual Exclusion and Idempotency in Distributed Systems: Problems, Principles, and Solutions
Java Architect Essentials
Java Architect Essentials
Sep 28, 2021 · R&D Management

How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work

This article explains the common misconceptions about software architects, outlines the essential technical and soft‑skill requirements for senior developers to become architects, describes practical upgrade paths, and details the typical responsibilities and daily activities of an architect.

Design Patternscareer developmentdistributed systems
0 likes · 13 min read
How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work
Architecture Digest
Architecture Digest
Sep 27, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Algorithms, and Implementations

This article explains why rate limiting is needed in both physical venues and online systems, describes common limiting strategies such as circuit breaking, service degradation, delayed processing, and privileged handling, and details three major algorithms—counter, leaky bucket, and token bucket—along with practical Java and Nginx‑Lua code examples.

Javaalgorithmconcurrency
0 likes · 13 min read
Understanding Rate Limiting: Concepts, Algorithms, and Implementations
Top Architect
Top Architect
Sep 26, 2021 · Fundamentals

Fundamentals of Distributed Systems: Concepts, Replication, Consistency, and Protocols

This article provides a comprehensive overview of distributed system fundamentals, covering system models, node concepts, failure types, replication strategies, consistency levels, data distribution methods, replica control protocols such as primary‑secondary, two‑phase commit, lease‑based caching, quorum, MVCC, Paxos, and the CAP theorem.

ConsistencyReplicationdistributed systems
0 likes · 54 min read
Fundamentals of Distributed Systems: Concepts, Replication, Consistency, and Protocols
IT Architects Alliance
IT Architects Alliance
Sep 23, 2021 · Fundamentals

Evolution and Comparative Analysis of UAV Software Architectures

This article surveys the historical development of command‑and‑control software for unmanned aerial vehicles, compares early, first‑ and second‑generation drone architectures, and examines modern open‑control platforms, distributed UAV frameworks, behavior‑based controllers, and future trends in UAV software design.

Control SystemsUAVdistributed systems
0 likes · 21 min read
Evolution and Comparative Analysis of UAV Software Architectures
Architecture Digest
Architecture Digest
Sep 23, 2021 · Operations

High Availability Practices: From Taobao to Cloud

This talk shares practical high‑availability strategies learned from years of building Taobao’s massive e‑commerce platform and migrating to Alibaba Cloud, covering traditional IDC stability mechanisms, cache and disaster‑recovery designs, cloud‑native fault‑tolerance, capacity planning, rate‑limiting, graceful degradation, and multi‑region resilience.

CachingCloud Computingcapacity planning
0 likes · 20 min read
High Availability Practices: From Taobao to Cloud
IT Architects Alliance
IT Architects Alliance
Sep 22, 2021 · Operations

Resource Isolation Strategies in Distributed Systems

The article explains why resource isolation is essential for distributed architectures, describes common isolation methods such as thread, process, cluster, data, static and crawler isolation, and provides concrete examples and code snippets for Netty, Dubbo, Tomcat, and Hystrix to illustrate practical implementations.

DubboNettyThread Isolation
0 likes · 12 min read
Resource Isolation Strategies in Distributed Systems
Laravel Tech Community
Laravel Tech Community
Sep 22, 2021 · Backend Development

Session Sharing Solutions in Distributed Environments: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie

The article explains why session sharing is critical in micro‑service and distributed deployments and presents four backend solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized session storage, and cookie‑based sessions—detailing their implementations, advantages, and drawbacks.

BackendNginxRedis
0 likes · 5 min read
Session Sharing Solutions in Distributed Environments: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie
Airbnb Technology Team
Airbnb Technology Team
Sep 22, 2021 · Backend Development

Design and Implementation of Himeji: A Zanzibar‑Based Centralized Authorization System at Airbnb

Airbnb replaced duplicated, latency‑prone authorization checks in its new service‑oriented architecture by moving them into data services and building Himeji, a Zanzibar‑inspired centralized permission store that uses triple‑based policies, configurable unions, sharded caching, and Aurora backing to deliver sub‑10 ms latency for millions of checks per second with 99.999 % availability.

BackendCachingZanzibar
0 likes · 12 min read
Design and Implementation of Himeji: A Zanzibar‑Based Centralized Authorization System at Airbnb
Top Architect
Top Architect
Sep 20, 2021 · Backend Development

Session Sharing Solutions in Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie

This article explains why session sharing is required in micro‑service and distributed environments and presents four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis centralized session cache, and cookie‑based sharing—detailing their implementations, code snippets, and pros and cons.

SessionTomcatdistributed systems
0 likes · 6 min read
Session Sharing Solutions in Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie
Selected Java Interview Questions
Selected Java Interview Questions
Sep 20, 2021 · Backend Development

An Introduction to Dubbo: Features, Architecture, and Usage

This article provides a comprehensive overview of Dubbo, the high‑performance Java RPC framework, covering its core components, advantages over alternatives, supported protocols, configuration methods, startup behavior, integration with Spring Boot, and detailed architecture for building scalable distributed services.

DubboJavaRPC
0 likes · 8 min read
An Introduction to Dubbo: Features, Architecture, and Usage
Programmer DD
Programmer DD
Sep 20, 2021 · Databases

Unlock Redis: 16 Real‑World Patterns for Caching, Locks, Queues, and More

This article explores sixteen practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—detailing data types, commands, and code snippets for each scenario.

CachingMessage QueueRedis
0 likes · 8 min read
Unlock Redis: 16 Real‑World Patterns for Caching, Locks, Queues, and More
Java Backend Technology
Java Backend Technology
Sep 20, 2021 · Backend Development

How to Achieve Exactly‑Once Message Processing in RocketMQ Without Transactions

This article explains why message middleware guarantees at‑least‑once delivery, the problems caused by duplicate consumption, and presents both transaction‑based and non‑transactional deduplication solutions—including a Redis‑backed idempotent table—to achieve exactly‑once semantics in RocketMQ.

Exactly-OnceIdempotenceRocketMQ
0 likes · 19 min read
How to Achieve Exactly‑Once Message Processing in RocketMQ Without Transactions
Top Architect
Top Architect
Sep 19, 2021 · Backend Development

Technical Summary of Large-Scale Distributed Website Architecture

This article provides a comprehensive technical overview of large-scale distributed website architecture, detailing its characteristics, goals, layered design patterns, performance and high‑availability optimizations, scalability strategies, extensibility practices, security measures, agile management, and evolutionary case studies for e‑commerce platforms.

distributed systemsload balancingscalability
0 likes · 21 min read
Technical Summary of Large-Scale Distributed Website Architecture
IT Architects Alliance
IT Architects Alliance
Sep 19, 2021 · R&D Management

30 Proven Architecture Principles Every Software Engineer Should Follow

This article presents 30 widely‑accepted software architecture principles—grouped into basics, feature selection, server design, distributed systems, user experience, and challenges—to help architects act as gardeners who shape, refine, and sustain robust, maintainable systems.

R&D Managementbest practicesdesign principles
0 likes · 12 min read
30 Proven Architecture Principles Every Software Engineer Should Follow
Top Architect
Top Architect
Sep 18, 2021 · Backend Development

Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More

The article explains why resource isolation is essential in distributed architectures and details various isolation strategies—including thread, process, cluster, data read/write, static, and crawler isolation—illustrated with Netty, Dubbo, Tomcat examples, code snippets, and a comparison of thread‑pool versus semaphore isolation in Hystrix.

DubboHystrixNetty
0 likes · 13 min read
Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More
Java Architect Essentials
Java Architect Essentials
Sep 17, 2021 · Backend Development

How to Achieve Exactly‑Once Message Processing in RocketMQ Without Transactions

This article analyzes the at‑least‑once guarantee of message middleware, explains why duplicate deliveries occur, compares simple database‑based deduplication methods, explores concurrency challenges, and presents a non‑transactional, status‑driven idempotence solution using MySQL or Redis with practical code examples and limitations.

Exactly-OnceIdempotenceMySQL
0 likes · 19 min read
How to Achieve Exactly‑Once Message Processing in RocketMQ Without Transactions
Architecture Digest
Architecture Digest
Sep 17, 2021 · Backend Development

Message Deduplication and Exactly-Once Semantics in RocketMQ

This article explains why message middleware guarantees at‑least‑once delivery, describes three common duplication scenarios in RocketMQ, and presents both transactional and non‑transactional deduplication solutions—including SQL examples and a Redis‑based idempotence library—to achieve exactly‑once processing.

Exactly-OnceIdempotenceRocketMQ
0 likes · 19 min read
Message Deduplication and Exactly-Once Semantics in RocketMQ
TAL Education Technology
TAL Education Technology
Sep 16, 2021 · Backend Development

Design and Architecture of MQProxy: A Distributed Message Queue Proxy for Kafka

MQProxy is a Java‑based distributed message‑queue proxy built on Apache Kafka that abstracts underlying queue selection, protocols, and health monitoring, offering developers a simple SDK with produce/consume/commit APIs, advanced features like delayed and dead‑letter queues, and a scalable architecture for high availability.

MQProxyMessage Queuedistributed systems
0 likes · 17 min read
Design and Architecture of MQProxy: A Distributed Message Queue Proxy for Kafka
Architecture Digest
Architecture Digest
Sep 16, 2021 · Databases

Designing High‑Throughput Payment Systems: Ant Group’s LDC Architecture, CRG Zones, and CAP Analysis

The article explains how Ant Group’s Alipay handles massive double‑11 payment traffic by using logical data centers (LDC), unit‑based architecture with RZone, GZone and CZone, traffic routing, disaster‑recovery strategies, and a CAP‑aware design built on the OceanBase distributed database.

CAP theoremDatabase ScalingHigh TPS
0 likes · 35 min read
Designing High‑Throughput Payment Systems: Ant Group’s LDC Architecture, CRG Zones, and CAP Analysis
Programmer DD
Programmer DD
Sep 16, 2021 · Backend Development

Why RocketMQ Solves Core Messaging Challenges – Architecture and Features Explained

This article examines the key problems message middleware must address—such as publish/subscribe, ordering, filtering, persistence, reliability, latency, and transaction support—and explains how Apache RocketMQ’s architecture and design choices provide high‑performance, high‑throughput solutions to each of these challenges.

Message QueueRocketMQarchitecture
0 likes · 17 min read
Why RocketMQ Solves Core Messaging Challenges – Architecture and Features Explained
vivo Internet Technology
vivo Internet Technology
Sep 15, 2021 · Backend Development

RocketMQ NameServer Architecture Design and Source Code Analysis

The article thoroughly examines RocketMQ’s NameServer, detailing its lightweight registration-center architecture, startup sequence, and the three core routing mechanisms—registration via broker heartbeats, timed removal of stale brokers, and client‑pulled discovery—while explaining key metadata tables and design patterns such as JVM shutdown hooks and read‑write locks for high‑concurrency safety.

NameServerRocketMQRoute Management
0 likes · 30 min read
RocketMQ NameServer Architecture Design and Source Code Analysis
Top Architect
Top Architect
Sep 15, 2021 · Operations

Why ZooKeeper Is Not the Best Choice for Service Discovery: Design Considerations for Registration Centers

This article examines why ZooKeeper may not be the optimal solution for service discovery, analyzing CAP trade‑offs, consistency versus availability, scalability limits, health‑check design, and practical lessons from Alibaba’s decade‑long experience to guide the design of robust registration centers.

CAPdistributed systemsregistration center
0 likes · 19 min read
Why ZooKeeper Is Not the Best Choice for Service Discovery: Design Considerations for Registration Centers
Java Interview Crash Guide
Java Interview Crash Guide
Sep 15, 2021 · Backend Development

How Taobao Scaled from 100 to Millions of Users: Backend Evolution

Using Taobao as a case study, this article traces the architectural evolution from a single-server setup handling hundreds of requests to a multi-layered, distributed system capable of supporting millions of concurrent users, detailing each stage’s challenges, technologies such as caching, load balancing, microservices, and cloud deployment.

Cloud Computingbackend architecturedistributed systems
0 likes · 24 min read
How Taobao Scaled from 100 to Millions of Users: Backend Evolution
Tencent Cloud Developer
Tencent Cloud Developer
Sep 14, 2021 · Backend Development

A Comparative Overview of Transactional Messaging in RocketMQ, Kafka, and Pulsar

The article compares how RocketMQ, Apache Kafka, and Apache Pulsar implement transactional messaging—each using a two‑phase commit with half‑messages or transaction buffers, distinct coordinators, and idempotent producers—to provide atomicity and either strong consistency (RocketMQ) or exactly‑once delivery for high‑throughput stream processing (Kafka and Pulsar).

Exactly-OnceKafkaMessage Queue
0 likes · 22 min read
A Comparative Overview of Transactional Messaging in RocketMQ, Kafka, and Pulsar
Architect
Architect
Sep 14, 2021 · Fundamentals

Understanding Distributed Transactions: From Local ACID to CAP Theory and Message‑Queue Solutions

The article uses a personal bank‑transfer incident to introduce local transaction concepts, explains the CAP theorem, examines the challenges of distributed transactions, and presents a message‑queue‑based design with transaction logs and compensation mechanisms to ensure consistency and idempotency.

CAP theoremMessage QueueTransactions
0 likes · 15 min read
Understanding Distributed Transactions: From Local ACID to CAP Theory and Message‑Queue Solutions
Java Interview Crash Guide
Java Interview Crash Guide
Sep 11, 2021 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Real-World Implementations

This article explains why rate limiting is essential, outlines common strategies such as circuit breaking, service degradation, delay processing, and privilege handling, compares counter, leaky‑bucket and token‑bucket algorithms, and provides practical Java and Nginx‑Lua implementation examples for backend systems.

circuit breakerconcurrency controldistributed systems
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Strategies, and Real-World Implementations
IT Architects Alliance
IT Architects Alliance
Sep 11, 2021 · Backend Development

Technical Summary of Large-Scale Distributed Website Architecture

This article provides a comprehensive technical overview of large‑scale distributed website architecture, covering its characteristics, design goals, architectural patterns, performance, high availability, scalability, extensibility, security, agility, and a detailed example evolution from a single‑server setup to a multi‑layer, service‑oriented system.

Cachingdistributed systemshigh availability
0 likes · 22 min read
Technical Summary of Large-Scale Distributed Website Architecture
Tencent Architect
Tencent Architect
Sep 10, 2021 · Databases

Design and Advantages of a Cloud‑Native ClickHouse OLAP System

This article presents the architecture, key features, and operational benefits of a cloud‑native ClickHouse OLAP platform, describing how storage‑compute separation, a unified master node, and shared storage reduce cost, improve availability, and simplify management while remaining fully compatible with the open‑source ClickHouse ecosystem.

ClickHouseOLAPdatabase architecture
0 likes · 18 min read
Design and Advantages of a Cloud‑Native ClickHouse OLAP System
Shopee Tech Team
Shopee Tech Team
Sep 9, 2021 · Backend Development

Technical Architecture and High‑Concurrency Solutions for Shopee Shake During Major Promotions

Shopee Shake’s architecture separates admin and user sides into three layers—access, application, and resource—and uses horizontal scaling, bucketed Redis coin pools, multi‑level caching, asynchronous message queues, precise capacity formulas, and comprehensive monitoring and chaos‑engineered runbooks to reliably handle over 300,000 QPS during major promotional events.

CachingHigh ConcurrencyShopee Shake
0 likes · 19 min read
Technical Architecture and High‑Concurrency Solutions for Shopee Shake During Major Promotions
Tencent Qidian Tech Team
Tencent Qidian Tech Team
Sep 9, 2021 · Databases

How MySync Achieves Real-Time MySQL Binlog Synchronization Across Heterogeneous Stores

This article explains the design and implementation of MySync, a component that leverages MySQL binlog to synchronously replicate data to heterogeneous storage systems such as Redis, ElasticSearch, and HBase, detailing its architecture, reader and writer modules, Kafka integration, and strategies for handling master‑slave failover.

BinlogMySQLdata synchronization
0 likes · 15 min read
How MySync Achieves Real-Time MySQL Binlog Synchronization Across Heterogeneous Stores
dbaplus Community
dbaplus Community
Sep 8, 2021 · Operations

Why Does a Single Kafka Broker Crash Bring Down All Consumers?

An in‑depth look at Kafka’s high‑availability mechanisms reveals how multi‑replica design, ISR leader election, and the request.required.acks setting interact, why a single broker failure—especially of the __consumer_offset topic—can halt consumption, and how to configure replication factors to prevent such outages.

ISRKafkaReplication
0 likes · 10 min read
Why Does a Single Kafka Broker Crash Bring Down All Consumers?
vivo Internet Technology
vivo Internet Technology
Sep 8, 2021 · Cloud Native

Overview of Dubbo Layered Architecture and Design

The article by the Vivo Internet Server Team details Apache Dubbo’s ten‑layer architecture—service, config, proxy, registry, cluster, monitor, protocol, exchange, transport, and serialization—explaining each layer’s role, the RPC invocation flow, registration/discovery mechanisms, configuration options, and how Dubbo’s extensive SPI‑based modular design enables loose coupling, extensibility, and robust micro‑service development.

DubboJavaRPC
0 likes · 24 min read
Overview of Dubbo Layered Architecture and Design
Tencent Database Technology
Tencent Database Technology
Sep 6, 2021 · Cloud Native

Cloud‑Native ClickHouse Architecture and Design Overview

This article presents a comprehensive design of a cloud‑native ClickHouse OLAP system, detailing its three‑layer architecture, storage‑compute separation, unified metadata management, high‑availability mechanisms, elastic scaling, cost reductions, and future enhancements for multi‑replica and MPP query support.

ClickHouseElastic ScalingOLAP
0 likes · 19 min read
Cloud‑Native ClickHouse Architecture and Design Overview
IT Architects Alliance
IT Architects Alliance
Sep 5, 2021 · Cloud Computing

What Are the Six Core Traits of Serverless Architecture and Their Challenges?

The article outlines six fundamental traits of serverless architecture—low barrier-to-entry, hostless, stateless, elasticity, distributed, and event-driven—explains why they matter, discusses the benefits and hidden challenges each introduces, and offers concise recommendations for developers to successfully adopt serverless solutions.

Cloud ComputingServerlessTraits
0 likes · 15 min read
What Are the Six Core Traits of Serverless Architecture and Their Challenges?
JD Tech
JD Tech
Sep 3, 2021 · Operations

High-Fidelity Load Testing: Practices and Technical Innovations from JD's ForceBot Platform

This article explains high-fidelity load testing, outlines the technical breakthroughs of JD's ForceBot platform—including massive traffic generation, full‑domain traffic recording and replay for both public and internal networks—and showcases its successful deployment during the 618 and Double‑11 shopping events.

JD ForceBotLoad Testingdistributed systems
0 likes · 8 min read
High-Fidelity Load Testing: Practices and Technical Innovations from JD's ForceBot Platform
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 3, 2021 · Backend Development

Distributed Real-Time Local Cache Practice in iQIYI TV Backend

iQIYI TV’s backend implements a distributed real‑time local cache that combines hotspot local storage with a unified messaging bus, management console, and business‑filtering to deliver instant updates, improve hit rates, reduce read‑bottleneck risk, and alleviate load on centralized caches under extreme concurrency.

High Concurrencycachedistributed systems
0 likes · 6 min read
Distributed Real-Time Local Cache Practice in iQIYI TV Backend
Architecture Digest
Architecture Digest
Sep 3, 2021 · Cloud Native

Why ZooKeeper Is Not the Best Choice for Service Discovery: Design Considerations for Registration Centers

The article analyzes the evolution of service registration in Alibaba, compares ZooKeeper with other solutions, and argues that for large‑scale service discovery a registration center should prioritize availability over strong consistency, support flexible health checks, handle partitions gracefully, and avoid the pitfalls of using ZooKeeper as a universal registry.

CAP theoremdistributed systemsregistration center
0 likes · 18 min read
Why ZooKeeper Is Not the Best Choice for Service Discovery: Design Considerations for Registration Centers
IT Architects Alliance
IT Architects Alliance
Sep 2, 2021 · Backend Development

Key Characteristics, Technical Challenges, and Evolution of Large-Scale Website Architecture

The article outlines the defining traits of large-scale websites—high concurrency, massive data, 24/7 availability, security, and rapid iteration—and discusses major technical challenges such as scaling, caching, clustering, database read/write separation, CDN acceleration, distributed storage, and service decomposition.

Cachingdatabase shardingdistributed systems
0 likes · 10 min read
Key Characteristics, Technical Challenges, and Evolution of Large-Scale Website Architecture
Top Architect
Top Architect
Sep 1, 2021 · Backend Development

Rate Limiting Strategies, Algorithms, and Implementations in Backend Systems

This article explains the concepts, strategies, and algorithms of rate limiting—including circuit breaking, service degradation, leaky‑bucket and token‑bucket methods—and provides practical Java, Guava, and Nginx + Lua implementations for controlling concurrency and protecting backend services.

BackendGuavaalgorithm
0 likes · 13 min read
Rate Limiting Strategies, Algorithms, and Implementations in Backend Systems
IT Architects Alliance
IT Architects Alliance
Aug 31, 2021 · Backend Development

Why Resource Isolation Matters: Thread, Process, and Cluster Strategies Explained

This article explores the importance of resource isolation in distributed systems, detailing thread, process, cluster, data‑center, read/write, static, and crawler isolation techniques, with practical code examples from Netty, Dubbo, and Tomcat, and discusses trade‑offs such as thread‑pool versus semaphore isolation.

Resource IsolationThread Isolationbackend architecture
0 likes · 13 min read
Why Resource Isolation Matters: Thread, Process, and Cluster Strategies Explained
Open Source Linux
Open Source Linux
Aug 30, 2021 · Big Data

Why Kafka’s Message System Is Essential for High‑Throughput Applications

This article explains why a message system like Kafka is crucial for decoupling services, handling asynchronous workflows such as e‑commerce flash sales, controlling traffic, and achieving high concurrency, high availability, and high performance through sequential disk writes, zero‑copy reads, replication, and careful resource planning.

High ConcurrencyKafkaMessage Queue
0 likes · 35 min read
Why Kafka’s Message System Is Essential for High‑Throughput Applications
Java Interview Crash Guide
Java Interview Crash Guide
Aug 30, 2021 · Backend Development

How to Achieve Exactly-Once Message Processing with RocketMQ Deduplication

Message middleware guarantees at-least-once delivery, but repeated deliveries cause duplicate processing; this article explains RocketMQ's duplicate scenarios, explores simple and advanced deduplication techniques—including database-transactional and Redis-based idempotent tables—and provides practical Java code for implementing exactly-once semantics.

Exactly-OnceIdempotenceRocketMQ
0 likes · 20 min read
How to Achieve Exactly-Once Message Processing with RocketMQ Deduplication
ITPUB
ITPUB
Aug 27, 2021 · Databases

What the Two‑Generals Problem Reveals About Distributed Transactions

This article uses the classic two‑generals story to illustrate communication failures in distributed systems, then explains local versus distributed transactions, their roles, scenarios, and classifications, linking concepts such as atomicity, retries, idempotence, and the three‑way handshake.

ACIDCAP theoremdistributed systems
0 likes · 11 min read
What the Two‑Generals Problem Reveals About Distributed Transactions
Architect's Tech Stack
Architect's Tech Stack
Aug 27, 2021 · Backend Development

Transaction Management Patterns in Microservices: Blocking Retry, Async Queue, TCC, and Local Message Table

The article explains common microservice transaction patterns—including blocking retry, asynchronous queues, TCC compensation transactions, and local message tables—detailing their implementations, advantages, drawbacks, and practical code examples for ensuring data consistency in distributed systems.

TCCdata consistencydistributed systems
0 likes · 14 min read
Transaction Management Patterns in Microservices: Blocking Retry, Async Queue, TCC, and Local Message Table
IT Architects Alliance
IT Architects Alliance
Aug 26, 2021 · Backend Development

Resource Isolation: Thread, Process, Cluster, and Other Strategies in Distributed Systems

This article explains why resource isolation is essential in distributed architectures and details various isolation techniques—including thread, process, cluster, data‑read/write, static, and crawler isolation—illustrated with Netty, Dubbo, and Tomcat examples, code snippets, and practical recommendations.

BackendThread Isolationdistributed systems
0 likes · 14 min read
Resource Isolation: Thread, Process, Cluster, and Other Strategies in Distributed Systems
Shopee Tech Team
Shopee Tech Team
Aug 26, 2021 · Databases

Database Architecture Evolution and Sharding Practice in Shopee's Logistics Service

Shopee’s Logistics Channel Service migrated from a shared‑cluster MySQL setup to dedicated clusters, added TiDB for transient tracking data, and ultimately adopted hash‑based sharding with separate order and tracking services plus an asynchronous compensation mechanism, enabling uniform data distribution, cross‑database consistency, six‑month archiving, and scalable growth without rebalancing.

MySQLTiDBdatabase architecture
0 likes · 18 min read
Database Architecture Evolution and Sharding Practice in Shopee's Logistics Service
Senior Brother's Insights
Senior Brother's Insights
Aug 25, 2021 · Backend Development

Mastering Cookies vs. Sessions: Deep Dive for Web Interviews

This article explains the fundamentals and advanced aspects of cookies and sessions, covering their definitions, use cases, key differences, handling when cookies are disabled, session management in distributed systems, same‑origin policy, cross‑origin requests, and security considerations for interview preparation.

HTTPSessionscookies
0 likes · 9 min read
Mastering Cookies vs. Sessions: Deep Dive for Web Interviews
Wukong Talks Architecture
Wukong Talks Architecture
Aug 25, 2021 · Backend Development

Designing Redis Cache for Billion‑Scale Systems: Challenges and Solutions

This article examines the essential concepts, common pitfalls such as cache stampede, penetration, avalanche, hot keys, large keys, consistency, and concurrent pre‑heating, and presents practical design patterns and mitigation techniques for building a robust Redis cache architecture that can handle billion‑scale traffic.

cache designdistributed systems
0 likes · 9 min read
Designing Redis Cache for Billion‑Scale Systems: Challenges and Solutions
IT Architects Alliance
IT Architects Alliance
Aug 23, 2021 · Backend Development

Mastering Cache Strategies: From CDN to Distributed Systems

This article provides a comprehensive overview of caching in large distributed systems, covering theory, common components, classification, CDN and reverse‑proxy caches, local application caches, popular implementations like Ehcache, Guava, Memcached and Redis, and a detailed comparison of their features and trade‑offs.

BackendCachingEhcache
0 likes · 12 min read
Mastering Cache Strategies: From CDN to Distributed Systems
Architecture Digest
Architecture Digest
Aug 22, 2021 · Operations

High Availability Practices: From Taobao to Cloud Migration

This talk shares practical high‑availability design experiences from Alibaba’s e‑commerce platform to its cloud services, covering traditional IDC stability mechanisms, cache and disaster‑recovery strategies, cloud‑native fault handling, capacity planning, traffic shaping, and lessons learned from real incidents.

Alibabacloud architecturedistributed systems
0 likes · 19 min read
High Availability Practices: From Taobao to Cloud Migration
Tencent Cloud Developer
Tencent Cloud Developer
Aug 19, 2021 · Backend Development

Message Queue Design Principles and Implementation Analysis

The article explains message queues, their primary use cases—async processing, system decoupling, and traffic peak shaving—compares five mainstream products (ActiveMQ, RabbitMQ, Kafka, RocketMQ, Pulsar), and examines core design principles such as architecture, storage choices, push/pull models, and consumer groups, highlighting broader relevance to distributed systems.

KafkaMessage QueueRabbitMQ
0 likes · 17 min read
Message Queue Design Principles and Implementation Analysis
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 19, 2021 · Operations

How Alibaba Conquered Double 11: Scaling to 17.5k TPS with High‑Availability Architecture

Alibaba’s eight‑year Double 11 journey illustrates how the company tackled exponential business growth by inventing high‑availability middleware, precise capacity planning, unit‑based deployment, online stress testing, hybrid‑cloud elasticity, and intelligent runtime control to balance throughput, cost, and user experience during the midnight peak.

Cloud Scalingcapacity planningdistributed systems
0 likes · 23 min read
How Alibaba Conquered Double 11: Scaling to 17.5k TPS with High‑Availability Architecture
IT Architects Alliance
IT Architects Alliance
Aug 17, 2021 · Backend Development

Meituan Instant Logistics: Distributed System Architecture, Practices, and Future Challenges

The article details Meituan’s five‑year evolution of its instant logistics platform, describing the distributed backend architecture, AI‑driven optimization, scalability and high‑availability practices, as well as future challenges in microservice complexity and operational automation.

AIOpsdistributed systemshigh availability
0 likes · 10 min read
Meituan Instant Logistics: Distributed System Architecture, Practices, and Future Challenges
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 17, 2021 · Backend Development

How Meituan Scaled Instant Logistics with Distributed Systems and AI

This article details Meituan's five‑year journey building a high‑availability, low‑latency instant logistics platform, describing the distributed architecture evolution, AI‑driven optimizations, fault‑tolerance techniques, and future challenges in scaling micro‑services for massive order and rider volumes.

AI logisticsAIOpsHigh Concurrency
0 likes · 12 min read
How Meituan Scaled Instant Logistics with Distributed Systems and AI
IT Architects Alliance
IT Architects Alliance
Aug 15, 2021 · Databases

Understanding Local Transactions, ACID, CAP/BASE Theories, and Distributed Transaction Solutions (Seata, 2PC, TCC, Saga)

This article explains the fundamentals of local transactions and ACID properties, introduces CAP and BASE theories, discusses compensation jobs and transaction messages, and reviews distributed transaction models such as two‑phase commit, three‑phase commit, XA, TCC, Saga, and the Seata framework.

ACIDCAP theoremdatabase
0 likes · 15 min read
Understanding Local Transactions, ACID, CAP/BASE Theories, and Distributed Transaction Solutions (Seata, 2PC, TCC, Saga)
Programmer DD
Programmer DD
Aug 15, 2021 · Operations

Zookeeper in Action: Config Management, Distributed Locks, Queues & Load Balancing

This article introduces Zookeeper fundamentals and demonstrates four real‑world scenarios—consistent configuration management, distributed locking, distributed queuing, and service load balancing—complete with Java code samples, workflow diagrams, and step‑by‑step explanations for building reliable distributed systems.

ZooKeeperconfiguration managementdistributed systems
0 likes · 16 min read
Zookeeper in Action: Config Management, Distributed Locks, Queues & Load Balancing
Big Data Technology Architecture
Big Data Technology Architecture
Aug 12, 2021 · Databases

Understanding HBase HLog and Fault Recovery Mechanisms

This article explains HBase's write path using Memstore and HLog, details the lifecycle of HLog including construction, rolling, expiration, and deletion, and thoroughly analyzes the three fault‑recovery models—Log Splitting, Distributed Log Splitting, and Distributed Log Replay—highlighting their processes, advantages, and configuration nuances.

HBaseHLogLog Splitting
0 likes · 14 min read
Understanding HBase HLog and Fault Recovery Mechanisms
Architects' Tech Alliance
Architects' Tech Alliance
Aug 11, 2021 · Databases

Database Disaster Recovery Technologies for the Financial Sector

This article examines financial sector database disaster recovery, defining disaster recovery and backup, analyzing current practices and requirements, reviewing market trends, and detailing various distributed database disaster‑recovery architectures such as single‑center, intra‑city active‑active, and multi‑site three‑center solutions.

Financialbackupdatabase
0 likes · 13 min read
Database Disaster Recovery Technologies for the Financial Sector
Code Ape Tech Column
Code Ape Tech Column
Aug 10, 2021 · Backend Development

How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis, and Cookie Solutions

This article explains why session sharing is critical in micro‑service architectures, compares common Nginx load‑balancing methods, and provides four practical solutions—ip_hash load balancing, Tomcat session replication, Redis‑based session caching, and cookie‑based sharing—complete with configuration examples and pros/cons.

BackendNginxRedis
0 likes · 6 min read
How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis, and Cookie Solutions