BestHub
Sign in
Tagged articles
2122 articles
Page 13 of 22
Java Backend Technology
Java Backend Technology
Mar 23, 2021 · Backend Development

How Transparent Multilevel Cache (TMC) Eliminates Hotspot Bottlenecks in High‑Traffic E‑Commerce

This article explains Youzan's Transparent Multilevel Cache (TMC), detailing its architecture, transparent Java integration, hotspot detection and local caching mechanisms, and demonstrates its real‑world performance gains during flash‑sale events and large‑scale marketing campaigns.

Distributed Systemscachinghotspot detection
0 likes · 16 min read
How Transparent Multilevel Cache (TMC) Eliminates Hotspot Bottlenecks in High‑Traffic E‑Commerce
Baidu Geek Talk
Baidu Geek Talk
Mar 22, 2021 · Operations

How Baidu Achieved 99.999% Uptime for Its Massive Feed Recommendation System

This article details Baidu's Feed recommendation system architecture, explaining how a combination of dynamic retry scheduling, real‑time stop‑loss mechanisms, multi‑recall frameworks, ranking layer fallbacks, and IDC‑level multi‑master designs collectively ensure five‑nine availability across billions of daily requests.

Distributed SystemsMicroservicesOperations
0 likes · 18 min read
How Baidu Achieved 99.999% Uptime for Its Massive Feed Recommendation System
Top Architect
Top Architect
Mar 20, 2021 · Backend Development

Scaling Cache Infrastructure at Pinterest

This article provides an in‑depth technical overview of how Pinterest scales its distributed cache layer using Memcached and Mcrouter on AWS, covering architecture, performance, high availability, load balancing, trade‑offs, and future directions.

AWSDistributed SystemsMemcached
0 likes · 16 min read
Scaling Cache Infrastructure at Pinterest
Wukong Talks Architecture
Wukong Talks Architecture
Mar 18, 2021 · Fundamentals

Understanding Distributed Theory and Algorithms: Importance, Core Concepts, and Learning Path

This article explains why distributed theory and algorithms are crucial for architects, outlines the four foundational theories and eight key protocols, discusses their four evaluation dimensions, and provides a step‑by‑step learning roadmap illustrated with stories and practical examples.

CAP theoremConsistencyDistributed Systems
0 likes · 10 min read
Understanding Distributed Theory and Algorithms: Importance, Core Concepts, and Learning Path
IT Architects Alliance
IT Architects Alliance
Mar 15, 2021 · Backend Development

Evolution of Meituan Instant Logistics Distributed System Architecture and Practices

The article details Meituan's five‑year journey in instant logistics, describing how distributed, high‑concurrency backend architectures were progressively upgraded to microservices, how AI is integrated for pricing, ETA and dispatch, and the operational techniques used to ensure scalability, fault tolerance, and high availability.

AIDistributed SystemsLogistics
0 likes · 8 min read
Evolution of Meituan Instant Logistics Distributed System Architecture and Practices
High Availability Architecture
High Availability Architecture
Mar 15, 2021 · Operations

OCTO 2.0: Architecture and Implementation of Meituan’s Next‑Generation Service Governance System

This article introduces OCTO 2.0, Meituan’s next‑generation distributed service‑governance platform, detailing its overall architecture, mesh‑related features such as traffic hijacking, service subscription, lossless hot‑restart, data‑plane operations, and future cloud‑native evolution plans.

Distributed SystemsHot RestartOperations
0 likes · 13 min read
OCTO 2.0: Architecture and Implementation of Meituan’s Next‑Generation Service Governance System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 15, 2021 · Operations

How Meituan Scales Instant Delivery with a Distributed Architecture

Meituan's instant logistics platform evolved over five years, adopting distributed, fault‑tolerant systems, AI‑driven optimization, and multi‑IDC strategies to handle massive order volumes, extreme traffic spikes, and stringent real‑time reliability requirements while continuously improving scalability and cost efficiency.

AI OptimizationDistributed SystemsMicroservices
0 likes · 10 min read
How Meituan Scales Instant Delivery with a Distributed Architecture
Meituan Technology Team
Meituan Technology Team
Mar 11, 2021 · Cloud Native

Meituan OCTO 2.0: Architecture, Service Mesh Features, and Operational Practices

Meituan’s OCTO 2.0 upgrades the company’s distributed service‑governance platform by reusing OCTO 1.0 infrastructure, adding a self‑developed control plane and a customized Envoy data‑plane that employ UDS traffic hijacking, on‑demand service discovery, loss‑less hot‑restart, and automated lifecycle management, while planning cloud‑native extensions and full‑link mTLS.

Cloud NativeDistributed SystemsHot Restart
0 likes · 13 min read
Meituan OCTO 2.0: Architecture, Service Mesh Features, and Operational Practices
IT Architects Alliance
IT Architects Alliance
Mar 9, 2021 · Backend Development

Understanding the Essence of Architecture and Scaling Strategies for Billion‑User Systems

This article explores the fundamental concepts of system architecture, illustrating how large‑scale services like Weibo handle massive traffic through layered design, sharding, caching, service decomposition, monitoring, and operational practices to achieve high performance and reliability.

ArchitectureDistributed SystemsMicroservices
0 likes · 20 min read
Understanding the Essence of Architecture and Scaling Strategies for Billion‑User Systems
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 7, 2021 · Backend Development

Comprehensive Guide to Java Backend Interview Experience and Preparation

This article shares a detailed personal account of multiple Java backend interview rounds, covering technical topics such as JVM, design patterns, distributed locks, Redis, and system design, while also offering practical advice on preparation, self‑presentation, career planning, and interview mindset.

Distributed SystemsJVMbackend interview
0 likes · 14 min read
Comprehensive Guide to Java Backend Interview Experience and Preparation
WeChat Backend Team
WeChat Backend Team
Mar 6, 2021 · Backend Development

How We Scaled a Live Chatroom to 15 Million Concurrent Users

This article details the evolution of a WeChat live‑room chat component from its 1.0 high‑performance design to a 2.0 architecture that overcomes scalability, reliability, and traffic‑isolation challenges, enabling a single room to support up to 15 million simultaneous online users.

ChatroomDistributed SystemsHyperLogLog
0 likes · 13 min read
How We Scaled a Live Chatroom to 15 Million Concurrent Users
IT Architects Alliance
IT Architects Alliance
Mar 5, 2021 · Backend Development

Understanding the Essence of System Architecture: Insights from Weibo’s Large‑Scale Design

The article explores the fundamental concepts of system architecture, illustrating how large‑scale services like Weibo handle massive traffic through layered design, abstraction, caching, service decomposition, monitoring, and operational practices to achieve scalability, reliability, and performance.

BackendDistributed SystemsScalable Design
0 likes · 20 min read
Understanding the Essence of System Architecture: Insights from Weibo’s Large‑Scale Design
Tencent Cloud Developer
Tencent Cloud Developer
Feb 26, 2021 · Fundamentals

Distributed Consistency Algorithms: CAP, BASE, Paxos, and Raft

From CAP and BASE trade‑offs to the rigorous Paxos consensus and the more approachable Raft protocol, this article explains how modern distributed systems achieve consistency despite partitions, failures, and latency, detailing roles, phases, and safety guarantees that underpin reliable micro‑service architectures.

BASE theoryCAP theoremConsistency
0 likes · 21 min read
Distributed Consistency Algorithms: CAP, BASE, Paxos, and Raft
Xianyu Technology
Xianyu Technology
Feb 26, 2021 · Backend Development

Design and Implementation of the Optimus Tag Management Platform for Xianyu Feeds

The Optimus platform centralizes Xianyu feed tag configuration into a three‑layer system of tags, scenes, and experiments, providing a console for AB testing, time‑ and version‑based targeting, fast HSF/Diamond client integration, parallel rule‑based data fetching, cutting latency from 120 ms to 15 ms and enabling rapid tag updates that boosted pCTR and pCVR, with plans to broaden coverage and add smarter personalization.

Distributed SystemsTag ManagementUI
0 likes · 9 min read
Design and Implementation of the Optimus Tag Management Platform for Xianyu Feeds
Wukong Talks Architecture
Wukong Talks Architecture
Feb 24, 2021 · Fundamentals

Understanding the Gossip Protocol Through a Virus Analogy

The article uses a whimsical story of a coronavirus‑like virus transmitted from a bat to humans to illustrate the Gossip protocol, its three functions—direct mail, anti‑entropy, and epidemic spread—and discusses their advantages, drawbacks, and practical applications in achieving eventual consistency in distributed systems.

Anti-entropyDistributed SystemsGossip Protocol
0 likes · 10 min read
Understanding the Gossip Protocol Through a Virus Analogy
macrozheng
macrozheng
Feb 22, 2021 · Backend Development

Master ZooKeeper: From Basics to Installation and Client Setup

This guide explains what ZooKeeper is, its core distributed coordination concepts, how to install it via binary packages or Docker, and provides an overview of available client libraries for Java, Python, Go, Node.js, and Ruby, helping developers quickly get started.

Distributed SystemsDockerInstallation
0 likes · 10 min read
Master ZooKeeper: From Basics to Installation and Client Setup
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 21, 2021 · Databases

How Ant Financial Scales to 540k TPS: Inside LDC Architecture, Unitization, and CAP Analysis

This article explains how Ant Financial’s payment system grew from 20,000 transactions per minute in 2010 to 540,000 TPS in 2019 by adopting logical data centers (LDC), unitized architecture (RZone, GZone, CZone), OceanBase’s Paxos‑based consensus, and sophisticated traffic steering and disaster‑recovery strategies.

CAP theoremDistributed SystemsOceanBase
0 likes · 41 min read
How Ant Financial Scales to 540k TPS: Inside LDC Architecture, Unitization, and CAP Analysis
Architects' Tech Alliance
Architects' Tech Alliance
Feb 17, 2021 · Databases

How Alipay Handles 540k TPS: Inside the LDC Architecture, Unitization and CAP Analysis

This article dissects Alipay's massive Double‑11 payment surge, explaining how its Logical Data Center (LDC) and unit‑based architecture—RZone, GZone, and CZone—scale to hundreds of thousands of transactions per second, manage traffic routing, implement disaster‑recovery, and navigate the CAP theorem using OceanBase and Paxos.

CAP theoremDistributed SystemsLDC architecture
0 likes · 39 min read
How Alipay Handles 540k TPS: Inside the LDC Architecture, Unitization and CAP Analysis
21CTO
21CTO
Feb 15, 2021 · Backend Development

From Java Developer to Architect: Lessons on Building High‑Concurrency Systems

The author reflects on their path from a senior Java developer to a software architect, describing early misconceptions, the pitfalls of over‑focusing on code, the importance of mastering existing components, and how design patterns and maintainability become essential when assembling high‑concurrency, distributed architectures.

Design PatternsDistributed SystemsSoftware Architecture
0 likes · 8 min read
From Java Developer to Architect: Lessons on Building High‑Concurrency Systems
Architects' Tech Alliance
Architects' Tech Alliance
Feb 15, 2021 · Industry Insights

How Taobao Scaled from LAMP to Cloud‑Native: Architecture Evolution and Migration Best Practices

The article traces Taobao’s architectural journey from its early LAMP stack through Oracle‑IBM mainframe solutions to a cloud‑native design on Alibaba Cloud, highlighting the challenges of availability, consistency, performance and scalability, and presenting concrete migration best‑practice patterns such as CDN, distributed caching, service‑oriented decomposition, and database sharding.

ArchitectureDistributed SystemsIndustry Insights
0 likes · 12 min read
How Taobao Scaled from LAMP to Cloud‑Native: Architecture Evolution and Migration Best Practices
Architect
Architect
Feb 14, 2021 · Backend Development

Message Idempotency and Exactly‑Once Processing in RocketMQ

This article explains why message middleware like RocketMQ guarantees at‑least‑once delivery, the resulting duplicate‑delivery problem, and presents both transaction‑based and non‑transactional idempotency solutions—including select‑for‑update, optimistic locking, and a Redis‑backed deduplication table—to achieve exactly‑once semantics in distributed systems.

Distributed SystemsExactly-OnceRocketMQ
0 likes · 16 min read
Message Idempotency and Exactly‑Once Processing in RocketMQ
Top Architect
Top Architect
Feb 14, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation

This article explains the fundamentals of rate limiting, its importance for high‑availability services, various classification dimensions, common algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and demonstrates practical usage with Go's golang.org/x/time/rate library including code examples and configuration tips.

Distributed SystemsGolangToken Bucket
0 likes · 26 min read
An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation
JD Tech
JD Tech
Feb 8, 2021 · Big Data

JD Remote Shuffle Service: Design, Implementation, and Performance Evaluation

This article presents JD's self‑developed Remote Shuffle Service for Spark, detailing its architecture, goals, implementation details, performance benchmarks, and real‑world production case studies that demonstrate its impact on shuffle efficiency and system stability in large‑scale data processing.

Distributed SystemsRemote Shuffle ServiceShuffle Optimization
0 likes · 17 min read
JD Remote Shuffle Service: Design, Implementation, and Performance Evaluation
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 3, 2021 · Operations

How to Build True Multi‑Region Active‑Active Architecture with Bidirectional Sync

This article explains why true multi‑region active‑active requires data to be bidirectionally synchronized across three or more centers, and details a multi‑center disaster‑recovery architecture, distributed ID generation algorithms, CAP considerations, and techniques for achieving eventual consistency.

Distributed Systemsdata synchronizationdisaster recovery
0 likes · 14 min read
How to Build True Multi‑Region Active‑Active Architecture with Bidirectional Sync
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 1, 2021 · Big Data

Kafka Overview: Architecture, Advantages, Disadvantages, and Core Concepts

This article provides a comprehensive introduction to Apache Kafka, covering its distributed publish‑subscribe architecture, its key components such as brokers, topics, partitions, producers, consumers, and ZooKeeper, as well as its advantages, drawbacks, storage mechanisms, partition assignment strategies, and reliability guarantees for high‑throughput big‑data streaming.

Big DataDistributed SystemsMessage Queue
0 likes · 20 min read
Kafka Overview: Architecture, Advantages, Disadvantages, and Core Concepts
Open Source Linux
Open Source Linux
Feb 1, 2021 · Cloud Native

From Single‑Node to Cloud‑Native: A Journey Through Storage Evolution

This article outlines the evolution of storage systems—from early single‑node solutions to modern cloud‑native architectures—detailing key storage types (block, file, object), models, and design principles of centralized, distributed, and cloud storage, providing a concise roadmap for newcomers.

Cloud NativeDistributed Systemsblock storage
0 likes · 8 min read
From Single‑Node to Cloud‑Native: A Journey Through Storage Evolution
21CTO
21CTO
Jan 31, 2021 · Backend Development

Mastering Load Balancing: From Random to Smooth Weighted Round‑Robin in Java

This article explains load‑balancing fundamentals, covering hardware vs. software devices, server‑side and client‑side balancing, and walks through common algorithms—random, weighted random, round‑robin, weighted and smooth weighted round‑robin, hash, consistent hash with virtual nodes, and least‑connection—each illustrated with Java code examples and diagrams.

Distributed Systemsalgorithm
0 likes · 18 min read
Mastering Load Balancing: From Random to Smooth Weighted Round‑Robin in Java
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jan 30, 2021 · Backend Development

Why Dubbo Remains a Top Java RPC Framework for Modern Backend Systems

This article traces Dubbo’s evolution from its Alibaba origins to its Apache graduation, outlines its core features such as protocol design, service registry, clustering, filters, and extensibility, and discusses recent cloud‑native and reactive programming directions shaping its future.

Cloud NativeDistributed SystemsDubbo
0 likes · 12 min read
Why Dubbo Remains a Top Java RPC Framework for Modern Backend Systems
21CTO
21CTO
Jan 28, 2021 · Backend Development

From Single Server to Cloud‑Native: Taobao’s 14‑Step Architecture Evolution

This article traces Taobao's backend architecture evolution—from a single‑server setup to distributed clusters, caching, load balancing, database sharding, microservices, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles that enable scaling from hundreds to millions of concurrent users.

Backend ArchitectureCloud NativeDistributed Systems
0 likes · 22 min read
From Single Server to Cloud‑Native: Taobao’s 14‑Step Architecture Evolution
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 28, 2021 · Fundamentals

Distributed Systems Essentials: Models, Replicas, Consistency & Protocols

This comprehensive guide explores the core concepts of distributed systems, covering node models, replica strategies, consistency levels, data distribution techniques, lease-based caching, quorum mechanisms, logging, two‑phase commit, MVCC, Paxos consensus, and the CAP theorem, providing practical insights for building robust scalable architectures.

ConsensusConsistencyDistributed Systems
0 likes · 55 min read
Distributed Systems Essentials: Models, Replicas, Consistency & Protocols
Architecture Digest
Architecture Digest
Jan 22, 2021 · Backend Development

Microservice Architecture and Its Ten Most Important Design Patterns

This article explains the fundamentals of microservice architecture, outlines its advantages and disadvantages, describes when it should be adopted, and details ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—providing practical guidance and technology examples for modern backend systems.

CQRSDesign PatternsDistributed Systems
0 likes · 21 min read
Microservice Architecture and Its Ten Most Important Design Patterns
Code Ape Tech Column
Code Ape Tech Column
Jan 21, 2021 · Interview Experience

Master Distributed System Interview Questions: CAP, Redis, Zookeeper, Kafka and More

This article compiles essential interview‑style questions and detailed answers on distributed system fundamentals—including CAP and BASE theories, consistency models, distributed transactions, Redis features and persistence, Zookeeper coordination, Kafka architecture, and common design patterns for high‑concurrency scenarios.

Distributed SystemsKafkaMessage Queue
0 likes · 38 min read
Master Distributed System Interview Questions: CAP, Redis, Zookeeper, Kafka and More
21CTO
21CTO
Jan 19, 2021 · Backend Development

Why We Shifted Away from Database‑Generated IDs to 64‑Bit Domain IDs

The article explains how our team, while building a SQL Server data catalog, adopted decoupling principles to avoid coupling business logic to a specific database, opting for domain‑generated 64‑bit IDs instead of database‑generated keys, and discusses the benefits of Snowflake‑style ID generators.

64-bit integerDistributed SystemsDomain-Driven Design
0 likes · 6 min read
Why We Shifted Away from Database‑Generated IDs to 64‑Bit Domain IDs
Code Ape Tech Column
Code Ape Tech Column
Jan 19, 2021 · Operations

Scaling Kafka Clusters to Support Millions of Partitions: Challenges and Solutions

This article examines the technical challenges of scaling Kafka clusters to handle millions of partitions—including Zookeeper node explosion, replication overhead, controller recovery latency, and broker restart delays—and proposes solutions such as parallel ZK fetching, metadata synchronization via internal topics, logical cluster composition, and physical cluster splitting.

Distributed SystemsKafkacluster operations
0 likes · 13 min read
Scaling Kafka Clusters to Support Millions of Partitions: Challenges and Solutions
IT Architects Alliance
IT Architects Alliance
Jan 18, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Architect Should Know

This comprehensive guide explains the evolution, core concepts, advantages, drawbacks, and practical usage scenarios of microservice architecture, then details ten critical design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—providing concrete examples, pros, cons, and technology recommendations.

ArchitectureBackendDesign Patterns
0 likes · 28 min read
10 Essential Microservice Design Patterns Every Architect Should Know
Open Source Linux
Open Source Linux
Jan 18, 2021 · Operations

Why ZooKeeper Is Essential for Distributed Application Coordination

This article explains ZooKeeper's purpose, core features, and design goals, showing how it simplifies distributed application development by providing high‑performance, highly available coordination services such as naming, locks, leader election, and configuration management while hiding low‑level complexities.

APIConsistencyDistributed Coordination
0 likes · 10 min read
Why ZooKeeper Is Essential for Distributed Application Coordination
Efficient Ops
Efficient Ops
Jan 17, 2021 · Big Data

Understanding Kafka: Core Concepts, Architecture, and Performance Secrets

This article introduces Kafka’s fundamental role as a messaging system, explains topics, partitions, producers, consumers, replicas, consumer groups, and the controller, and explores its cluster architecture, performance optimizations like sequential writes and zero-copy, providing a comprehensive overview for building scalable data pipelines.

Big DataDistributed SystemsMessage Queue
0 likes · 11 min read
Understanding Kafka: Core Concepts, Architecture, and Performance Secrets
ITPUB
ITPUB
Jan 12, 2021 · Databases

What the Latest DTCC Conference Reveals About the Future of Databases

The DTCC conference recap explores emerging data trends, multi‑model databases, governance frameworks, architecture migrations, NewSQL and MySQL high‑availability, distributed transaction challenges, AI‑driven operations, data middle‑platform debates, cloud‑native storage‑compute separation, and comprehensive data security across the full data lifecycle.

Cloud ComputingData GovernanceDistributed Systems
0 likes · 19 min read
What the Latest DTCC Conference Reveals About the Future of Databases
Programmer DD
Programmer DD
Jan 12, 2021 · Backend Development

Mastering Cache Strategies: Preventing Bottlenecks in High‑Traffic Systems

This article explains how large‑scale internet applications can use various caching patterns—such as Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind—to alleviate database pressure, maintain data consistency, and avoid pitfalls like cache penetration, avalanche, and thundering under extreme traffic loads.

Backend PerformanceDistributed Systemscache patterns
0 likes · 9 min read
Mastering Cache Strategies: Preventing Bottlenecks in High‑Traffic Systems
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 11, 2021 · Backend Development

Understanding RPC and the Dubbo Framework: Concepts, Demo Code, Architecture and SPI Mechanism

This article explains the fundamentals of Remote Procedure Call (RPC), provides a complete Java RPC demo, introduces the Dubbo distributed RPC framework with its layered architecture, SPI extension mechanism, service exposure and reference processes, and discusses clustering, fault‑tolerance and load‑balancing strategies for building robust backend services.

Distributed SystemsRPCSPI
0 likes · 23 min read
Understanding RPC and the Dubbo Framework: Concepts, Demo Code, Architecture and SPI Mechanism
Programmer DD
Programmer DD
Jan 11, 2021 · Backend Development

Mastering Cache Strategies: Prevent Database Bottlenecks in High‑Traffic Systems

This article explains how large‑scale internet applications can use various caching patterns—Cache‑Aside, Read‑Through, Write‑Through, Write‑Behind—and mitigation techniques for consistency, stampede, penetration, jitter, and avalanche to keep databases from becoming performance bottlenecks under massive traffic spikes.

Backend PerformanceCache ConsistencyDistributed Systems
0 likes · 9 min read
Mastering Cache Strategies: Prevent Database Bottlenecks in High‑Traffic Systems
Top Architect
Top Architect
Jan 8, 2021 · Backend Development

Microservice Architecture Communication Design Patterns

This article explains the challenges of cross‑service communication in microservice architectures and presents a comprehensive set of design patterns—including synchronous and asynchronous messaging, event‑driven approaches, saga, event sourcing, CQRS, outbox, CDC, idempotency, eventual consistency, distributed tracing, and service mesh—to help engineers build reliable, scalable distributed systems.

CQRSDistributed SystemsEvent Sourcing
0 likes · 17 min read
Microservice Architecture Communication Design Patterns
High Availability Architecture
High Availability Architecture
Jan 8, 2021 · Backend Development

Why We Shifted Away from Database-Generated IDs to 64‑Bit Integer IDs

The article explains how decoupling persistence from a specific database engine and moving ID generation to the domain layer using 64‑bit integer identifiers—leveraging the Twitter Snowflake algorithm and the IdGen library—improves scalability, reduces coupling, and avoids the storage overhead of UUIDs.

64-bit integerBackend ArchitectureDistributed Systems
0 likes · 6 min read
Why We Shifted Away from Database-Generated IDs to 64‑Bit Integer IDs
Top Architect
Top Architect
Jan 7, 2021 · Backend Development

Microservice Architecture and Its 10 Most Important Design Patterns

This article explains microservice architecture, outlines its ten essential design patterns—including database per service, event sourcing, CQRS, saga, BFF, API gateway, strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—detailing their advantages, drawbacks, usage scenarios, and typical technology stacks.

Distributed SystemsMicroservices
0 likes · 28 min read
Microservice Architecture and Its 10 Most Important Design Patterns
DataFunTalk
DataFunTalk
Jan 6, 2021 · Big Data

Didi's Presto Engine: Architecture, Optimizations, and Operational Practices

This article presents Didi's three‑year experience with Presto, detailing its architecture, low‑latency design, large‑scale deployment, extensive Hive compatibility work, resource isolation, Druid connector integration, usability enhancements, stability engineering, performance tuning, and future directions for the ad‑hoc query engine.

Big DataDistributed SystemsDruid Connector
0 likes · 17 min read
Didi's Presto Engine: Architecture, Optimizations, and Operational Practices
Efficient Ops
Efficient Ops
Jan 5, 2021 · Operations

How to Prevent ZooKeeper Split‑Brain: Best Practices and Fault‑Tolerance Strategies

This article explains why ZooKeeper clusters should use an odd number of nodes, how the majority quorum mechanism avoids split‑brain scenarios, and outlines practical solutions such as quorums, redundant communication, fencing, arbitration, and disk‑lock techniques to ensure reliable distributed coordination.

Distributed SystemsSplit-BrainZooKeeper
0 likes · 14 min read
How to Prevent ZooKeeper Split‑Brain: Best Practices and Fault‑Tolerance Strategies
JD Cloud Developers
JD Cloud Developers
Jan 5, 2021 · Databases

How ClickHouse Powers High‑Performance Time‑Series Data Management at JD’s JUST Engine

This article explains how JD’s JUST platform leverages the open‑source columnar database ClickHouse to store, query and analyze massive time‑series datasets, covering data modeling, lifecycle management, cluster architecture, write and query processes, scaling strategies and future enhancements.

ClickHouseData ManagementDistributed Systems
0 likes · 21 min read
How ClickHouse Powers High‑Performance Time‑Series Data Management at JD’s JUST Engine
Laravel Tech Community
Laravel Tech Community
Jan 3, 2021 · Backend Development

Apache RocketMQ 4.8.0 Released with Major DLedger Performance Improvements

Apache RocketMQ 4.8.0 has been released, featuring extensive optimizations and bug fixes, with significant performance, functionality, and stability enhancements to the Raft‑based DLedger mode, including asynchronous pipeline processing, batch log replication, and various lock and cache improvements that boost throughput by multiple times.

DLedgerDistributed SystemsMessaging
0 likes · 4 min read
Apache RocketMQ 4.8.0 Released with Major DLedger Performance Improvements
Java Architect Essentials
Java Architect Essentials
Jan 3, 2021 · Databases

Understanding Ant Financial’s LDC Architecture: Partitioning, CAP Analysis, and Multi‑Active Disaster Recovery

This article explains how Ant Financial’s logical data center (LDC) architecture uses unitization, database sharding, and CAP‑aware design—including RZone, GZone, and CZone—to achieve tens of millions of TPS during Double‑11, while providing multi‑active disaster recovery and high availability.

CAP theoremDistributed SystemsLDC architecture
0 likes · 38 min read
Understanding Ant Financial’s LDC Architecture: Partitioning, CAP Analysis, and Multi‑Active Disaster Recovery
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 1, 2021 · Cloud Computing

Taobao’s Journey from LAMP to Cloud: Architecture Evolution & Migration Secrets

This article chronicles Taobao’s rapid growth from a simple LAMP stack in 2003 to a sophisticated, cloud‑native architecture, detailing each major redesign, the challenges faced, and the best‑practice migration strategies that enabled high availability, scalability, and performance on Alibaba Cloud.

Alibaba CloudArchitectureCloud Computing
0 likes · 10 min read
Taobao’s Journey from LAMP to Cloud: Architecture Evolution & Migration Secrets
Architects Research Society
Architects Research Society
Dec 30, 2020 · Fundamentals

Key Challenges in Designing Distributed Systems

Designing a distributed system involves overcoming major challenges such as heterogeneity, transparency, openness, concurrency, security, scalability, and fault tolerance, each requiring careful consideration of hardware, software, network, and management aspects to build robust, scalable, and secure architectures.

Distributed SystemsScalabilitySystem Design
0 likes · 9 min read
Key Challenges in Designing Distributed Systems
ITPUB
ITPUB
Dec 29, 2020 · Databases

How BaikalDB’s Columnar Storage Boosted Real‑Time Analytics at DTCC2020

This article details how the DTCC2020 guest speaker from Tongcheng‑Elong introduced BaikalDB’s distributed columnar storage, covering internal and external motivations, technology comparison, architecture, implementation tricks, performance gains in production, and future hybrid row‑column research directions.

BaikalDBColumnar StorageDistributed Systems
0 likes · 12 min read
How BaikalDB’s Columnar Storage Boosted Real‑Time Analytics at DTCC2020
MaGe Linux Operations
MaGe Linux Operations
Dec 28, 2020 · Backend Development

Mastering Elasticsearch: Core Concepts and Indexing Workflow Explained

This article introduces Elasticsearch’s core concepts—including clusters, node roles, documents, mappings, and shards—and walks through the complete indexing workflow from client request to replica synchronization, highlighting key settings, routing calculations, and the role of refresh and flush operations.

ClusterDistributed SystemsElasticsearch
0 likes · 13 min read
Mastering Elasticsearch: Core Concepts and Indexing Workflow Explained
Suning Technology
Suning Technology
Dec 25, 2020 · Blockchain

Understanding EOS: Architecture, Consensus, and Enterprise Applications

This article explores EOS as a leading Blockchain 3.0 platform, detailing its layered architecture, consensus mechanisms, resource management model, account system, smart contract framework, and how Suning leverages EOS for a scalable distributed data storage solution.

BlockchainConsensusDistributed Systems
0 likes · 28 min read
Understanding EOS: Architecture, Consensus, and Enterprise Applications
Tencent Cloud Developer
Tencent Cloud Developer
Dec 24, 2020 · Big Data

Distributed Search Engine Design and Index Management in WeChat Search

The article details WeChat Search’s practical distributed architecture—using a Chubby‑elected leader for shard‑to‑node mapping, hash‑based sharding with dynamic rebalancing, a Lambda‑style batch and near‑real‑time indexing pipeline, relaxed monotonic consistency, and group‑based searcher scaling—to illustrate trade‑offs and lessons for building scalable, reliable search services.

Distributed SystemsIndex ManagementLSM
0 likes · 28 min read
Distributed Search Engine Design and Index Management in WeChat Search
vivo Internet Technology
vivo Internet Technology
Dec 23, 2020 · Backend Development

How Vivo Scaled Its Order System: Sharding, Migration, and Real‑World Lessons

This article details how Vivo transformed its monolithic e‑commerce order service into a scalable, service‑oriented system by applying data archiving, sharding‑JDBC based sharding, MySQL‑to‑Elasticsearch sync, zero‑downtime migration, and distributed‑transaction techniques, while sharing practical pitfalls and performance results.

Distributed SystemsElasticsearchMicroservices
0 likes · 17 min read
How Vivo Scaled Its Order System: Sharding, Migration, and Real‑World Lessons
vivo Internet Technology
vivo Internet Technology
Dec 23, 2020 · Cloud Native

ZooKeeper: Comprehensive Guide to Distributed Coordination Service

ZooKeeper, Apache’s distributed coordination service, offers a highly available in‑memory hierarchical file system with leader‑follower‑observer clustering and the ZAB protocol, guaranteeing sequential consistency, atomicity and a single view while supporting publish/subscribe, configuration management, distributed locks, master election and queueing for robust distributed applications.

ApacheCluster ManagementCoordination Service
0 likes · 20 min read
ZooKeeper: Comprehensive Guide to Distributed Coordination Service
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 17, 2020 · Big Data

Why GraphScope is Revolutionizing Large-Scale Graph Computing for AI and Big Data

GraphScope, an open‑source one‑stop platform from Alibaba DAMO Academy, unifies interactive queries, graph analytics, and graph learning on massive, rapidly evolving graphs, offering high‑performance distributed memory management, Gremlin optimization, and seamless Python integration to tackle real‑world AI and big‑data challenges.

Big DataDistributed SystemsOpen-source
0 likes · 21 min read
Why GraphScope is Revolutionizing Large-Scale Graph Computing for AI and Big Data
Java Architecture Diary
Java Architecture Diary
Dec 17, 2020 · Backend Development

How to Implement Rate Limiting in Microservices with Resilience4j

This article explains why rate limiting is essential for resilient microservices, demonstrates a simple e‑commerce order flow, and provides step‑by‑step code examples using Resilience4j to restrict request throughput, handle overload, and automatically retry failed calls.

Distributed SystemsMicroservicesresilience4j
0 likes · 6 min read
How to Implement Rate Limiting in Microservices with Resilience4j
IT Architects Alliance
IT Architects Alliance
Dec 13, 2020 · Backend Development

From Monolith to Microservices: A Practical Journey Through Modern Architecture

This article chronicles the evolution of software architecture from monolithic applications to microservices, detailing each stage's advantages and drawbacks, and enumerates the essential technology stack—including service communication, API gateways, authentication, fault handling, tracing, logging, configuration, containers, orchestration, and CI/CD—that enables building scalable, resilient backend systems.

ArchitectureCI/CDCloud Native
0 likes · 16 min read
From Monolith to Microservices: A Practical Journey Through Modern Architecture
Top Architect
Top Architect
Dec 13, 2020 · Backend Development

Practical Guide to Application and Database Splitting: Preparation, Implementation, and Stability

This article presents a comprehensive, step‑by‑step guide on why and how to split monolithic applications and databases, covering business complexity analysis, service boundary definition, migration planning, global ID generation, data sync, query refactoring, switch‑over strategies, consistency guarantees, and post‑split stability measures.

Backend ArchitectureDistributed SystemsMicroservices
0 likes · 16 min read
Practical Guide to Application and Database Splitting: Preparation, Implementation, and Stability
Wukong Talks Architecture
Wukong Talks Architecture
Dec 11, 2020 · Fundamentals

Byzantine Generals Problem Illustrated with Three Kingdoms Card Game

This article uses the popular Chinese card game Three Kingdoms to illustrate the Byzantine Generals Problem, explaining its relevance to distributed consensus, outlining four foundational theories and eight protocols, and demonstrating how voting, message tampering, and signature mechanisms affect agreement among nodes.

Byzantine Fault ToleranceDistributed SystemsThree Kingdoms
0 likes · 14 min read
Byzantine Generals Problem Illustrated with Three Kingdoms Card Game
IT Architects Alliance
IT Architects Alliance
Dec 10, 2020 · Industry Insights

How Alipay Handles 540K TPS: Inside LDC’s Unit‑Based Architecture and CAP Strategies

This article analyzes the massive traffic handling of Alipay during Double 11, explaining the LDC (Logical Data Center) unit‑based design, the RZone‑GZone‑CZone hierarchy, traffic steering, disaster‑recovery mechanisms, and how OceanBase and Paxos enable CAP compliance for ultra‑high‑availability payments.

CAP theoremDistributed SystemsLDC architecture
0 likes · 38 min read
How Alipay Handles 540K TPS: Inside LDC’s Unit‑Based Architecture and CAP Strategies
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 10, 2020 · Databases

How Ant Financial’s LDC Architecture Scales to 540k TPS on Double‑11

This article explains how Ant Financial’s logical data center (LDC) architecture, based on user‑sharded RZones, GZones, and CZones, combined with OceanBase’s Paxos‑based consensus, enables massive horizontal scaling, high availability, and disaster‑tolerant processing of over half a million payment transactions per second during Double‑11.

CAP theoremDistributed SystemsOceanBase
0 likes · 35 min read
How Ant Financial’s LDC Architecture Scales to 540k TPS on Double‑11
Java Architecture Diary
Java Architecture Diary
Dec 9, 2020 · Backend Development

Implementing Retry Patterns in Microservices with Resilience4j

Learn how to design resilient microservices by implementing retry mechanisms using Resilience4j, including configuration, code examples for order and product services, handling exceptions, and testing the automatic retry behavior to improve system availability while noting limitations for non‑idempotent APIs.

Distributed SystemsMicroservicesRetry
0 likes · 7 min read
Implementing Retry Patterns in Microservices with Resilience4j
MaGe Linux Operations
MaGe Linux Operations
Dec 8, 2020 · Fundamentals

Mastering ZooKeeper: Core Concepts, Architecture, and Guarantees

This article provides a comprehensive overview of ZooKeeper, covering its purpose, design goals, hierarchical data model, session handling, watch mechanism, consistency guarantees, leader election, role workflows, and the Zab protocol that ensures reliable state replication across a distributed cluster.

Coordination ServiceDistributed SystemsZAB Protocol
0 likes · 16 min read
Mastering ZooKeeper: Core Concepts, Architecture, and Guarantees
Java Architect Essentials
Java Architect Essentials
Dec 6, 2020 · Backend Development

Why Game Servers Resist Microservices: Real‑Time Constraints Explained

The article analyzes why many game server architectures avoid microservices, highlighting real‑time latency requirements, stateful processing, network overhead, and the mismatch between typical microservice patterns and the high‑performance demands of multiplayer online battle arena games.

Backend ArchitectureDistributed SystemsMicroservices
0 likes · 9 min read
Why Game Servers Resist Microservices: Real‑Time Constraints Explained
Selected Java Interview Questions
Selected Java Interview Questions
Dec 3, 2020 · Backend Development

Comprehensive Guide to Java Design Patterns, Distributed Systems, and Core Algorithms

This article provides an extensive overview of common Java design patterns—including Singleton, Factory, Proxy, Observer, and Decorator—along with detailed code examples, followed by discussions of distributed system concepts, CAP theorem, BASE theory, and fundamental algorithms such as sorting and binary search.

AlgorithmsDesign PatternsDistributed Systems
0 likes · 41 min read
Comprehensive Guide to Java Design Patterns, Distributed Systems, and Core Algorithms
Top Architect
Top Architect
Dec 3, 2020 · Fundamentals

Understanding Distributed Architecture: Concepts, Applications, and Evolution

This article explains the fundamentals of distributed architecture, describing its definition, key characteristics such as cohesion and transparency, common applications like distributed file systems, caches, and databases, and outlines the evolutionary stages from single‑server setups to clusters, load balancing, caching, CDN, NoSQL, and service‑oriented designs.

ArchitectureDistributed SystemsMicroservices
0 likes · 10 min read
Understanding Distributed Architecture: Concepts, Applications, and Evolution
IT Architects Alliance
IT Architects Alliance
Dec 2, 2020 · Operations

Understanding High Availability: Sources of Complexity and Decision Strategies

The article explains high availability as a source of system complexity, describing how redundancy, hardware and software failures, external disasters, and state‑decision mechanisms such as dictatorial, negotiated, and democratic approaches affect both compute and storage layers, and discusses trade‑offs like the CAP theorem.

CAP theoremDistributed SystemsSystem Design
0 likes · 12 min read
Understanding High Availability: Sources of Complexity and Decision Strategies
21CTO
21CTO
Dec 1, 2020 · Big Data

How Kafka Implements Transactions: Inside the TC Service and Producer Workflow

This article provides a comprehensive walkthrough of Kafka's transaction mechanism, covering the transaction coordinator, producer initialization, partition handling, commit and abort processes, state management, high‑availability design, timeout handling, and relevant source code snippets.

Distributed SystemsKafkaProducer
0 likes · 22 min read
How Kafka Implements Transactions: Inside the TC Service and Producer Workflow
IT Architects Alliance
IT Architects Alliance
Nov 29, 2020 · Backend Development

Why High Performance Makes Software Architecture So Complex—and How to Tame It

The article analyzes how the relentless pursuit of high performance drives both single‑machine and cluster‑level architectural complexity, explaining the evolution from batch processing to multi‑core CPUs, the trade‑offs of processes, threads, SMP/NUMA/MPP, and the challenges of task allocation and decomposition in large‑scale systems.

BackendDistributed SystemsPerformance
0 likes · 16 min read
Why High Performance Makes Software Architecture So Complex—and How to Tame It
Top Architect
Top Architect
Nov 29, 2020 · Backend Development

Software Architecture Patterns: Traditional Three‑Tier, Cluster, Distributed, and Microservice Architectures

This article explains common software architecture patterns—including traditional three‑tier, cluster (horizontal scaling), distributed (vertical splitting), and microservice (vertical division) architectures—detailing their components, advantages, drawbacks, and configuration examples such as Tomcat clustering with Nginx load balancing.

BackendDistributed SystemsMicroservices
0 likes · 9 min read
Software Architecture Patterns: Traditional Three‑Tier, Cluster, Distributed, and Microservice Architectures
Bitu Technology
Bitu Technology
Nov 27, 2020 · Backend Development

Steps 4–9 of Tubi's Advertising Pipeline: Pacing, Bid Collection, Video Transcoding, Bidding, Rendering, and Integration

The article details Tubi's ad‑serving pipeline from pacing control through bid collection, video transcoding, CPU‑intensive bidding optimization, result rendering, and final integration, highlighting the use of Akka, Spark, CRDTs, and gRPC in a distributed backend architecture.

Ad TechDistributed SystemsVideo Transcoding
0 likes · 7 min read
Steps 4–9 of Tubi's Advertising Pipeline: Pacing, Bid Collection, Video Transcoding, Bidding, Rendering, and Integration
Code Ape Tech Column
Code Ape Tech Column
Nov 26, 2020 · Backend Development

Understanding RabbitMQ: Architecture, Messaging Patterns, Persistence, Clustering, and Flow Control

This article provides a comprehensive overview of RabbitMQ, covering its origins, core components, message publishing and consumption, routing modes, persistence mechanisms, delivery guarantees, RPC support, clustering design, mirrored‑queue architecture, and flow‑control strategies for reliable backend messaging.

AMQPBackendDistributed Systems
0 likes · 13 min read
Understanding RabbitMQ: Architecture, Messaging Patterns, Persistence, Clustering, and Flow Control
Architect's Tech Stack
Architect's Tech Stack
Nov 24, 2020 · Backend Development

Understanding RPC: Principles, Architecture, and Common Frameworks

This article explains why RPC is essential for distributed services, defines its core concepts and architecture, compares it with REST, SOAP and SOA, outlines the components and call flow, and reviews key technologies and popular Java‑based RPC frameworks such as Dubbo, Thrift and Avro.

Distributed SystemsRPCService Architecture
0 likes · 15 min read
Understanding RPC: Principles, Architecture, and Common Frameworks
DevOps Cloud Academy
DevOps Cloud Academy
Nov 23, 2020 · Cloud Native

How to Set Up an etcd Cluster and Deploy It on Kubernetes

This guide walks through installing etcd, launching a static three‑node pseudo‑cluster on a single host, explains key command‑line flags, and shows how to deploy, configure, and scale the etcd cluster in Kubernetes using a corrected StatefulSet manifest.

ClusterDevOpsDistributed Systems
0 likes · 16 min read
How to Set Up an etcd Cluster and Deploy It on Kubernetes
Architecture Digest
Architecture Digest
Nov 22, 2020 · Operations

Stateful Services and High‑Availability Solutions: From Cold Backup to Multi‑Region Active‑Active

This article examines stateful backend services and various high‑availability strategies—including cold backup, active/standby hot backup, same‑city active‑active, cross‑region active‑active, and multi‑active architectures—detailing their advantages, limitations, and practical implementation considerations, and includes real‑world examples from major e‑commerce platforms.

Distributed Systemsactive standbycold backup
0 likes · 14 min read
Stateful Services and High‑Availability Solutions: From Cold Backup to Multi‑Region Active‑Active
Architects' Tech Alliance
Architects' Tech Alliance
Nov 20, 2020 · Operations

High‑Availability Deployment: From Cold Backup to Multi‑Active Architecture

This article explains the evolution of high‑availability deployment architectures—from simple cold backups and hot standby to same‑city active‑active, cross‑city active‑active, and finally multi‑active solutions—detailing their advantages, drawbacks, and practical design considerations for large‑scale internet services.

Distributed SystemsSystem Architecturemulti-active
0 likes · 15 min read
High‑Availability Deployment: From Cold Backup to Multi‑Active Architecture
Tencent Cloud Developer
Tencent Cloud Developer
Nov 19, 2020 · Backend Development

Kafka Message Queue Reliability Design and Implementation

The article thoroughly explains Kafka’s message‑queue reliability design and implementation, covering use‑case scenarios, core concepts, storage format, producer acknowledgment settings, broker replication mechanisms (ISR, HW, LEO), consumer delivery semantics, the epoch solution for synchronization, and practical configuration guidelines for various consistency and availability requirements.

BrokerConsistencyConsumer
0 likes · 15 min read
Kafka Message Queue Reliability Design and Implementation
Amap Tech
Amap Tech
Nov 19, 2020 · Operations

TestPG Load‑Testing Platform: Precise Pressure Control Architecture and Practice

The TestPG load‑testing platform, built on a master‑slave architecture with Redis‑driven dynamic configuration, delivers fine‑grained, cluster‑ and interface‑level pressure control that automates load‑generator allocation, shortens holiday testing cycles to three days, and produces realistic traffic models for Gaode’s nationwide services.

AutomationDistributed SystemsLoad Testing
0 likes · 14 min read
TestPG Load‑Testing Platform: Precise Pressure Control Architecture and Practice
Programmer DD
Programmer DD
Nov 19, 2020 · Backend Development

Why and How to Split a Monolithic Application: Practical Guide

This article explains why monolithic systems need to be split, outlines multi‑dimensional preparation steps, details database vertical and horizontal partitioning, global ID generation, cut‑over strategies, consistency handling, and operational safeguards to ensure a smooth migration.

Backend ArchitectureDistributed Systemsapplication splitting
0 likes · 17 min read
Why and How to Split a Monolithic Application: Practical Guide
Java High-Performance Architecture
Java High-Performance Architecture
Nov 18, 2020 · Big Data

Why Pulsar Might Outperform Kafka: Key Advantages and Drawbacks

This article examines Apache Pulsar, an open‑source messaging platform created by Yahoo, compares it with Kafka by outlining Kafka’s common pain points, highlights Pulsar’s multi‑tenant architecture, layered storage, built‑in functions, and security features, and discusses the trade‑offs of each solution.

Apache PulsarBig DataDistributed Systems
0 likes · 6 min read
Why Pulsar Might Outperform Kafka: Key Advantages and Drawbacks
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Nov 17, 2020 · Backend Development

How to Become a Software Coach: A Step‑by‑Step Learning Roadmap

This guide outlines a multi‑stage roadmap for developers to grow into software coaches, covering essential Java fundamentals, agile practices, algorithms, testing, design patterns, JVM internals, distributed middleware, big‑data ecosystems, architecture design, performance tuning, and emerging fields like AI and IoT.

Career DevelopmentDesign PatternsDistributed Systems
0 likes · 11 min read
How to Become a Software Coach: A Step‑by‑Step Learning Roadmap
Architecture Digest
Architecture Digest
Nov 15, 2020 · Cloud Native

Ele.me's Multi‑Active Architecture: Design Principles, Core Components and Implementation Overview

This article explains how Ele.me built a multi‑active, geographically distributed system that enables elastic scaling and data‑center‑level disaster recovery by partitioning services, routing traffic, replicating data in real time, and enforcing strict consistency and availability principles.

Distributed Systemsdata replicationmulti-active
0 likes · 18 min read
Ele.me's Multi‑Active Architecture: Design Principles, Core Components and Implementation Overview
JD Tech Talk
JD Tech Talk
Nov 13, 2020 · Artificial Intelligence

Practical Engineering Guide to Federated Learning: Deployment, Training, and Inference

This article provides a comprehensive engineering overview of federated learning, covering its core distributed‑learning concept, Docker‑based deployment, detailed training‑service architecture with validation, scheduling, metadata, and model‑management components, as well as a complete inference framework and workflow for production use.

AI EngineeringDistributed SystemsDocker
0 likes · 12 min read
Practical Engineering Guide to Federated Learning: Deployment, Training, and Inference
Practical DevOps Architecture
Practical DevOps Architecture
Nov 10, 2020 · Databases

Design of Ant Financial's Logical Data Center (LDC) and Unitization for High‑TPS Payments

The article explains how Ant Financial’s Logical Data Center (LDC) and unit‑based architecture, combined with sharding, CAP analysis, and OceanBase’s Paxos‑based consensus, enable the payment platform to sustain tens of millions of transactions per second during Double‑11 events while ensuring high availability and disaster recovery.

CAP theoremDistributed SystemsHigh TPS
0 likes · 42 min read
Design of Ant Financial's Logical Data Center (LDC) and Unitization for High‑TPS Payments