BestHub
Sign in
Tagged articles
2124 articles
Page 10 of 22
Architect
Architect
Dec 31, 2021 · Operations

Understanding Distributed System High Availability: From Single‑Node to Multi‑Active Architecture

This article explains the principles, evolution, and implementation details of high‑availability architectures—from basic single‑node setups to multi‑active, cross‑region deployments—covering redundancy, disaster recovery, data synchronization, routing strategies, and the challenges of achieving true geo‑distributed active‑active systems.

Active-ActiveDistributed SystemsSystem architecture
0 likes · 30 min read
Understanding Distributed System High Availability: From Single‑Node to Multi‑Active Architecture
FunTester
FunTester
Dec 31, 2021 · Operations

FunTester’s 2021 Leap: 100k+ QPS Performance & Distributed Testing Insights

The 2021 year‑end summary details FunTester’s rapid growth, the expansion of its public account, major performance upgrades reaching over 100 k QPS, the design of a distributed testing framework, dynamic load models, log‑replay innovations, and the author’s deep dive into Go, Java and Groovy.

Distributed SystemsGoTesting framework
0 likes · 10 min read
FunTester’s 2021 Leap: 100k+ QPS Performance & Distributed Testing Insights
IT Architects Alliance
IT Architects Alliance
Dec 31, 2021 · Industry Insights

A Complete 19‑Part Knowledge Map for Software Architects

The article presents a detailed 19‑section knowledge map for software architects, covering everything from core responsibilities and fundamentals to distributed caching, messaging, load balancing, performance testing, OS, algorithms, networking, databases, JVM, micro‑services, DDD, security, high availability, big data, and blockchain, with visual mind‑maps for each topic.

Big DataBlockchainDistributed Systems
0 likes · 4 min read
A Complete 19‑Part Knowledge Map for Software Architects
21CTO
21CTO
Dec 27, 2021 · Backend Development

How to Design a Scalable Twitter‑Like Backend from Scratch

This article outlines the functional and non‑functional requirements, traffic calculations, service decomposition, and detailed microservice designs needed to build a highly available, scalable Twitter‑style system using distributed caches, databases, and asynchronous processing.

BackendDistributed SystemsScalability
0 likes · 14 min read
How to Design a Scalable Twitter‑Like Backend from Scratch
Top Architect
Top Architect
Dec 22, 2021 · Operations

Load Balancing: Principles, Types, and Algorithms

This article explains the fundamentals of load balancing, covering its purpose, vertical and horizontal scaling, various classifications such as DNS, IP, link‑layer and hybrid methods, common algorithms like round‑robin and weighted, as well as hardware solutions, providing a comprehensive guide for building scalable, high‑availability systems.

AlgorithmsDistributed SystemsScaling
0 likes · 13 min read
Load Balancing: Principles, Types, and Algorithms
21CTO
21CTO
Dec 17, 2021 · Backend Development

Mastering Cache: Benefits, Strategies, and Optimization Techniques

This article explores how caching accelerates read/write performance and reduces backend load, analyzes its benefits and costs, and presents practical strategies for cache updates, granularity control, penetration, avalanche, and hot‑key issues with concrete examples and diagrams.

Cache ConsistencyCachingDistributed Systems
0 likes · 14 min read
Mastering Cache: Benefits, Strategies, and Optimization Techniques
High Availability Architecture
High Availability Architecture
Dec 16, 2021 · Big Data

iQIYI Basic Data Platform: Architecture, High Availability, and Service Practices

The iQIYI Basic Data Platform unifies internal data exchange standards, integrates massive multi‑business data, and implements high‑availability solutions for ID services, messaging, HBase storage, and read‑write scaling, showcasing practical engineering approaches to big‑data reliability and performance.

Big DataDistributed SystemsHBase
0 likes · 11 min read
iQIYI Basic Data Platform: Architecture, High Availability, and Service Practices
Architect
Architect
Dec 15, 2021 · Backend Development

Cache Optimization Techniques and Design Strategies

This article explains how caching improves application performance and reduces backend load, and it details practical optimization methods such as benefit‑cost analysis, update policies, granularity control, penetration protection, bottomless‑hole mitigation, avalanche prevention, and hot‑key rebuild strategies, primarily using Redis.

Distributed SystemsOptimizationRedis
0 likes · 15 min read
Cache Optimization Techniques and Design Strategies
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Dec 14, 2021 · Backend Development

How NetEase Cloud’s Distributed Recording Cluster Ensures High‑Availability and Scalability

This article explains the architecture and key features of NetEase Cloud's local server‑side recording cluster, detailing how dynamic scaling, multi‑backup high availability, load‑balancing strategies, monitoring, and an embedded registration center enable secure, reliable, and scalable recording for data‑sensitive applications.

Distributed SystemsJava SDKREST API
0 likes · 11 min read
How NetEase Cloud’s Distributed Recording Cluster Ensures High‑Availability and Scalability
Top Architect
Top Architect
Dec 10, 2021 · Operations

Comprehensive Guide to Load Balancing: Principles, Types, Algorithms, and Hardware

This article explains the fundamentals of load balancing, covering why it is needed for high‑traffic services, the difference between vertical and horizontal scaling, various load‑balancing techniques (DNS, HTTP, IP, link‑layer, hybrid), common algorithms, and the trade‑offs of software versus hardware solutions.

Distributed SystemsOperationsScalability
0 likes · 13 min read
Comprehensive Guide to Load Balancing: Principles, Types, Algorithms, and Hardware
Architects Research Society
Architects Research Society
Dec 9, 2021 · 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 of which must be addressed to build a reliable, extensible, and performant system.

ConcurrencyDistributed SystemsScalability
0 likes · 7 min read
Key Challenges in Designing Distributed Systems
Wukong Talks Architecture
Wukong Talks Architecture
Dec 8, 2021 · Big Data

Understanding Kafka Core Concepts: Architecture, Messaging Models, Partitioning, Consumer Groups, and Reliability

This article provides a comprehensive overview of Kafka, covering its layered architecture with Zookeeper, core concepts such as topics, partitions and consumer groups, communication workflow, partition selection strategies, rebalancing mechanisms, reliability configurations, replica synchronization, and reasons for moving away from Zookeeper, all explained in clear English.

Distributed SystemsKafkaReliability
0 likes · 19 min read
Understanding Kafka Core Concepts: Architecture, Messaging Models, Partitioning, Consumer Groups, and Reliability
Architects' Tech Alliance
Architects' Tech Alliance
Dec 6, 2021 · Backend Development

Designing High‑Concurrency Architecture: Strategies, Components, and Best Practices

This article explains how to design a high‑concurrency system by selecting appropriate server architecture, load balancing, database clustering, caching layers, message‑queue handling, static‑content delivery, service‑oriented decomposition, redundancy, automation, and monitoring to ensure smooth operation under heavy user traffic.

CachingDistributed SystemsMessage queue
0 likes · 17 min read
Designing High‑Concurrency Architecture: Strategies, Components, and Best Practices
Wukong Talks Architecture
Wukong Talks Architecture
Dec 6, 2021 · Fundamentals

RocketMQ Core Concepts, Windows Installation, Configuration, and Best Practices

This article provides a comprehensive guide to RocketMQ, covering Windows installation, environment configuration, startup commands, visual monitoring integration, SpringBoot dependency setup, core components, message models, reliability strategies, idempotent processing, transactional messaging, and ordering guarantees for distributed systems.

Best PracticesDistributed SystemsInstallation
0 likes · 37 min read
RocketMQ Core Concepts, Windows Installation, Configuration, and Best Practices
Architecture Digest
Architecture Digest
Dec 6, 2021 · Backend Development

Designing High‑Concurrency Architecture for E‑commerce Applications

This article explains how to design and evolve server architectures, load‑balancing, database clustering, caching, message queues, and other techniques to handle high‑concurrency scenarios such as flash sales and timed red‑packet distribution in large‑scale e‑commerce systems.

CachingDistributed SystemsScalability
0 likes · 21 min read
Designing High‑Concurrency Architecture for E‑commerce Applications
Architects Research Society
Architects Research Society
Dec 5, 2021 · Databases

Understanding Sequential, Causal, and Eventual Consistency Models

This article explains the concepts of sequential, causal, and eventual consistency models, illustrating their definitions, guarantees, and practical examples—including process interactions and real‑world scenarios—while comparing their strengths, trade‑offs, and related consistency guarantees such as monotonic reads, writes, and read‑your‑writes.

ConsistencyDatabasesDistributed Systems
0 likes · 10 min read
Understanding Sequential, Causal, and Eventual Consistency Models
Top Architect
Top Architect
Dec 4, 2021 · Backend Development

Cache Usage Techniques and Design Solutions: Benefits, Costs, Update Strategies, Granularity, and Common Optimizations

This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, discusses update strategies, granularity control, and solutions for common problems such as cache penetration, empty‑hole, avalanche, and hot‑key reconstruction, providing practical guidelines for robust backend design.

Backend PerformanceCache InvalidationDistributed Systems
0 likes · 14 min read
Cache Usage Techniques and Design Solutions: Benefits, Costs, Update Strategies, Granularity, and Common Optimizations
Top Architect
Top Architect
Dec 3, 2021 · Backend Development

High-Concurrency Architecture Design and Best Practices for Backend Systems

This article explains how to design and optimize backend server architecture for high‑concurrency scenarios, covering load balancing, database master‑slave clusters, NoSQL caching, concurrency testing tools, caching strategies, message‑queue based async processing, layered and distributed designs, redundancy, automation, and service‑oriented approaches.

Backend ArchitectureDistributed SystemsMessage queue
0 likes · 19 min read
High-Concurrency Architecture Design and Best Practices for Backend Systems
Open Source Linux
Open Source Linux
Dec 2, 2021 · Backend Development

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

This article explains why rate limiting is essential for system stability, outlines common throttling patterns such as circuit breaking, degradation, delayed processing, and privilege handling, and dives into popular algorithms like counter, leaky bucket, and token bucket with concrete Java and Nginx examples.

ConcurrencyDistributed SystemsRate Limiting
0 likes · 13 min read
Mastering Rate Limiting: Strategies, Algorithms, and Real-World Implementations
IT Architects Alliance
IT Architects Alliance
Nov 30, 2021 · Backend Development

Designing High‑Concurrency Architecture: Server Layout, Caching, Message Queues, and Distributed Strategies

The article explains how to design a high‑concurrency system by planning server architecture, load balancing, master‑slave databases, NoSQL clusters, caching layers, message‑queue based asynchronous processing, static‑content CDN, and automated redundancy to ensure scalability and reliability.

BackendBackend ArchitectureCaching
0 likes · 18 min read
Designing High‑Concurrency Architecture: Server Layout, Caching, Message Queues, and Distributed Strategies
Efficient Ops
Efficient Ops
Nov 29, 2021 · Operations

How SOFARegistry 6.0 Revolutionizes Service Discovery for Massive Scale

This article reviews the 13‑year evolution of Ant Group's registration center, analyzes the scaling and reliability challenges of multi‑cluster service discovery, and explains how the SOFARegistry 6.0 redesign—featuring meta‑driven consistency, slot‑based sharding, application‑level discovery, chaos testing, and automated operations—addresses those challenges while preparing the project for open‑source community growth.

Distributed Systemsautomationtesting
0 likes · 21 min read
How SOFARegistry 6.0 Revolutionizes Service Discovery for Massive Scale
Top Architect
Top Architect
Nov 27, 2021 · Backend Development

Design and Implementation of a High‑Concurrency Flash‑Sale (Seckill) System

The article explains the characteristics of flash‑sale scenarios, presents core design principles such as rate limiting, peak shaving, asynchronous processing and scalability, and details a complete backend and frontend architecture—including Redis‑based queueing and caching—to build a robust, high‑throughput seckill system.

Distributed SystemsRate LimitingRedis
0 likes · 12 min read
Design and Implementation of a High‑Concurrency Flash‑Sale (Seckill) System
IT Architects Alliance
IT Architects Alliance
Nov 26, 2021 · Operations

Large-Scale Distributed Website Architecture: Principles, Patterns, and Practices

This article provides a comprehensive technical summary of large‑scale distributed website architecture, covering characteristics, goals, architectural patterns, performance, high‑availability, scalability, extensibility, security, agility, and a detailed evolution roadmap with practical examples and recommendations.

CachingDistributed SystemsScalability
0 likes · 22 min read
Large-Scale Distributed Website Architecture: Principles, Patterns, and Practices
Tencent Cloud Middleware
Tencent Cloud Middleware
Nov 24, 2021 · Backend Development

Deep Dive into ZooKeeper 3.5.5: Server Startup, Leader Election, and Request Processing

This article provides a comprehensive analysis of ZooKeeper 3.5.5 source code, covering the distributed‑mode server startup sequence, leader election algorithm, cluster data synchronization, server role responsibilities, and the request‑processor pipeline, offering practical insights for developers and operators.

Distributed SystemsRequest ProcessingServer Startup
0 likes · 22 min read
Deep Dive into ZooKeeper 3.5.5: Server Startup, Leader Election, and Request Processing
IT Architects Alliance
IT Architects Alliance
Nov 24, 2021 · Operations

Designing High‑Availability, High‑Performance, Scalable and Secure Architecture for Large Web Applications

This article explains how to evolve a large‑scale website architecture through stages such as initial single‑server setups, application‑data separation, caching, server clustering, read‑write separation, CDN/reverse proxy, distributed storage, micro‑services, and automation to achieve high availability, scalability, performance and security.

CachingDistributed SystemsScalability
0 likes · 21 min read
Designing High‑Availability, High‑Performance, Scalable and Secure Architecture for Large Web Applications
dbaplus Community
dbaplus Community
Nov 23, 2021 · Databases

Doris vs ClickHouse: Which MPP Database Wins for Large‑Scale OLAP?

This article compares Apache Doris and ClickHouse across architecture, deployment, multi‑tenant management, data import, storage, query capabilities, performance testing, and cost, providing practical guidance for selecting the most suitable analytical database in large‑scale OLAP scenarios.

Apache DorisClickHouseDistributed Systems
0 likes · 26 min read
Doris vs ClickHouse: Which MPP Database Wins for Large‑Scale OLAP?
IT Architects Alliance
IT Architects Alliance
Nov 23, 2021 · Backend Development

Design and Architecture of a Cloud Shopping Cart System

The article explains the functional purpose, early evolution, layered and clustered design, distributed technical architecture, caching, asynchronous checks, heterogeneous storage, payment solutions, and anti‑bot measures of a cloud‑based shopping cart, highlighting stability, performance, elasticity, and fault‑tolerance.

BackendCachingDistributed Systems
0 likes · 6 min read
Design and Architecture of a Cloud Shopping Cart System
Architects' Tech Alliance
Architects' Tech Alliance
Nov 22, 2021 · Operations

How to Build a High‑Availability, High‑Performance, Scalable Web Architecture

This article analyzes the evolution of large‑scale website architecture, covering stages from single‑server setups to layered, distributed, and clustered designs, and explains how caching, read‑write separation, CDN, asynchronous messaging, redundancy, automation, and security collectively achieve high performance, availability, scalability, and extensibility.

CachingDistributed SystemsScalability
0 likes · 21 min read
How to Build a High‑Availability, High‑Performance, Scalable Web Architecture
Top Architect
Top Architect
Nov 22, 2021 · Backend Development

Designing High‑Concurrency Backend Architecture: Strategies, Tools, and Best Practices

This article presents a comprehensive guide to designing high‑concurrency backend systems, covering server architecture, load balancing, database and NoSQL clustering, caching strategies, concurrency testing tools, message‑queue solutions, first‑level cache, static data handling, layering, distribution, asynchronous processing, redundancy and automation.

Backend ArchitectureDistributed SystemsMessage queue
0 likes · 19 min read
Designing High‑Concurrency Backend Architecture: Strategies, Tools, and Best Practices
IT Architects Alliance
IT Architects Alliance
Nov 22, 2021 · Backend Development

How to Serve 1 Million Users Buying 10 000 Train Tickets Simultaneously – A High‑Concurrency Architecture Walkthrough

This article analyzes the extreme‑traffic problem of Chinese train ticket sales, presents a multi‑layer load‑balancing architecture with Nginx weighted round‑robin, demonstrates Go and Redis code for local and global stock deduction, and shows benchmark results proving that a single machine can handle over 4 000 requests per second while preventing oversell and few‑sell.

Backend DevelopmentDistributed SystemsGo
0 likes · 20 min read
How to Serve 1 Million Users Buying 10 000 Train Tickets Simultaneously – A High‑Concurrency Architecture Walkthrough
IT Architects Alliance
IT Architects Alliance
Nov 21, 2021 · R&D Management

Mastering Software Architecture: From Basics to Evolution

This comprehensive guide explains the essence of software architecture, its layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, and key metrics for evaluating a sound architecture.

Architecture PatternsBest PracticesDistributed Systems
0 likes · 22 min read
Mastering Software Architecture: From Basics to Evolution
Architects' Tech Alliance
Architects' Tech Alliance
Nov 20, 2021 · Cloud Computing

Edge Computing: Concepts, Differences from Centralized Computing, and Reference Architectures

The article explains edge computing as a new, global computing model that extends cloud computing by bringing compute, storage, and services closer to users, detailing its differences from centralized computing, its resource‑edge and global‑resource characteristics, and several reference architectures such as ETSI, Intel MEC, ECC, and OpenFog.

Distributed Systemsreference architectureresource allocation
0 likes · 11 min read
Edge Computing: Concepts, Differences from Centralized Computing, and Reference Architectures
Java Architect Essentials
Java Architect Essentials
Nov 19, 2021 · Fundamentals

A Comprehensive Guide to Learning Distributed Systems

This article provides a thorough overview of distributed systems, explaining their definition, core concepts such as partition and replication, key challenges, essential characteristics, typical components and protocols, a practical request flow example, and a curated list of real‑world implementations to help readers build a solid learning roadmap.

ConsistencyDistributed SystemsPartition
0 likes · 17 min read
A Comprehensive Guide to Learning Distributed Systems
IT Architects Alliance
IT Architects Alliance
Nov 19, 2021 · Backend Development

Technical Summary of Large‑Scale Distributed Website Architecture

This article provides a comprehensive overview of the design principles, architectural patterns, performance, availability, scalability, security, and operational considerations for building large distributed web sites, illustrated with a step‑by‑step evolution from a single‑server setup to a multi‑layer, cloud‑native architecture.

CachingDistributed SystemsScalability
0 likes · 22 min read
Technical Summary of Large‑Scale Distributed Website Architecture
IT Architects Alliance
IT Architects Alliance
Nov 15, 2021 · Industry Insights

Why Kafka’s Topic‑Partition Design Powers Scalable Messaging

This article explains Kafka’s core architecture—including topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance tricks like sequential writes and zero‑copy—to show how it achieves high‑throughput, fault‑tolerant messaging for large‑scale systems.

Distributed SystemsKafkaMessage queue
0 likes · 11 min read
Why Kafka’s Topic‑Partition Design Powers Scalable Messaging
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 12, 2021 · Backend Development

Code-less Business Process Orchestration: Design, Implementation, and Application

This article presents a code-less business process orchestration framework that transforms static Go code into configurable drag‑and‑drop workflows, detailing the underlying concepts, architecture, core Go data structures, dynamic configuration, and practical deployment examples for distributed task scheduling and execution.

Distributed SystemsGolangOrchestration
0 likes · 18 min read
Code-less Business Process Orchestration: Design, Implementation, and Application
Java High-Performance Architecture
Java High-Performance Architecture
Nov 12, 2021 · Databases

Elasticsearch Cluster Architecture: Nodes, Shards, and Deployment Options

This article explains the core concepts of Elasticsearch’s distributed architecture—including nodes, indices, shards, replicas—and compares mixed and tiered deployment models, while also discussing data storage strategies, replica benefits, and the trade‑offs of local‑file versus shared‑storage distributed systems.

Distributed SystemsElasticsearchreplica
0 likes · 15 min read
Elasticsearch Cluster Architecture: Nodes, Shards, and Deployment Options
Baidu Geek Talk
Baidu Geek Talk
Nov 10, 2021 · Operations

How etcd Powers Scalable Service Governance: Raft, BoltDB, and Real‑World Practices

This article explores service governance fundamentals, examines why etcd’s Raft‑based consensus and BoltDB storage make it ideal for large‑scale systems, compares it with ZooKeeper and Consul, and shares Baidu’s practical architecture, performance tricks, and operational metrics for high‑availability, high‑performance service management.

BoltDBDistributed SystemsPerformance Optimization
0 likes · 23 min read
How etcd Powers Scalable Service Governance: Raft, BoltDB, and Real‑World Practices
IT Architects Alliance
IT Architects Alliance
Nov 9, 2021 · Operations

Why Scale and How: Hardware Expansion, AKF Splitting Principle, Distributed ID Generation, and Elastic Scaling

The article explains the reasons for scaling, outlines hardware and component expansion strategies, introduces the AKF splitting principle for distributed systems, discusses database clustering and distributed ID generation methods such as UUID and Snowflake, and describes elastic scaling challenges and solutions.

Distributed SystemsID generationScaling
0 likes · 14 min read
Why Scale and How: Hardware Expansion, AKF Splitting Principle, Distributed ID Generation, and Elastic Scaling
Architecture Digest
Architecture Digest
Nov 9, 2021 · Operations

Scaling Strategies: Hardware Expansion, AKF Partitioning, and Distributed ID Generation

This article explains why scaling is necessary, outlines hardware and component expansion strategies, introduces the AKF partitioning principle for horizontal and vertical scaling, discusses challenges after splitting, and reviews database clustering and distributed ID generation techniques such as UUID and Snowflake, highlighting their advantages and drawbacks.

Distributed SystemsID generationdatabase clustering
0 likes · 15 min read
Scaling Strategies: Hardware Expansion, AKF Partitioning, and Distributed ID Generation
DataFunSummit
DataFunSummit
Nov 8, 2021 · Big Data

Building JD's OLAP System: From Data Ingestion to Management and Future Plans

This article explains how JD.com designs and evolves its OLAP platform, covering data sources, ingestion, storage, real‑time and offline processing, key challenges such as timeliness, high throughput, consistency, and the solutions implemented to support massive e‑commerce analytics.

Big DataData WarehouseDistributed Systems
0 likes · 13 min read
Building JD's OLAP System: From Data Ingestion to Management and Future Plans
DataFunTalk
DataFunTalk
Nov 6, 2021 · Artificial Intelligence

Elastic Federated Learning Solution (EFLS): Project Overview, Architecture, and Technical Implementation

The article introduces Alibaba's Elastic Federated Learning Solution (EFLS), describing its business motivations, core functionalities, system architecture, sample‑set intersection, federated training pipeline, novel algorithms, product console, and future roadmap for privacy‑preserving advertising in large‑scale sparse scenarios.

AdvertisingDistributed SystemsFlink
0 likes · 18 min read
Elastic Federated Learning Solution (EFLS): Project Overview, Architecture, and Technical Implementation
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.

Backend ArchitectureDistributed SystemsMessage queue
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.

Consistent HashingDistributed SystemsNetty
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.

Consistent HashingDistributed SystemsSpring Boot
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.

Distributed SystemsResource Isolationprocess isolation
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.

Distributed SystemsMessage queueStreaming
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.

Distributed SystemsSystem Designdisaster recovery
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.

Distributed SystemsGoRedis
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.

ConsistencyDistributed SystemsJepsen
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 theoremDistributed SystemsHigh TPS
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.

Circuit BreakerDistributed SystemsGuava
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.

Big DataClickHouseCluster Deployment
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 17, 2021 · Backend Development

Building a Scalable Go-Based Instant Messaging System: Architecture & Deployment Guide

Learn how to build a pure Go instant messaging platform with a three‑layer, distributed architecture—comet, logic, and job—featuring RPC communication, Redis‑based message pushing, and cluster support, plus step‑by‑step deployment instructions, required packages, and future enhancement plans.

Distributed SystemsGoInstant Messaging
0 likes · 5 min read
Building a Scalable Go-Based Instant Messaging System: Architecture & Deployment Guide
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 OffsetDistributed SystemsKafka
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 OffsetsDistributed SystemsIdempotence
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.

CachingDistributed Systemsbackend 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.

DeduplicationDistributed SystemsExactly-Once
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.

CachingDistributed SystemsScalability
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.

Distributed Systemsfailure designhigh 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.

ConsensusDistributed SystemsRaft
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 SystemsScalability
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.

Backend DevelopmentBaidu SearchDistributed Systems
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.

Distributed SystemsNear Real-Time SearchSegment Merging
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.

BaiduDistributed SystemsKV storage
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.

Distributed SystemsKafkaMessage queue
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.

Distributed SystemsKunpengcore banking
0 likes · 10 min read
How China’s Postal Savings Bank Built a Distributed Core System with OpenGauss and Kunpeng
Tencent Cloud Developer
Tencent Cloud Developer
Oct 8, 2021 · Operations

Unveiling Kafka’s Controller: Architecture, Election, and Monitoring Deep Dive

This article provides a comprehensive technical analysis of Kafka’s Controller component, covering its background, core responsibilities, data storage, election process, version‑specific improvements, monitoring techniques, and key source‑code excerpts to help engineers understand and manage Kafka clusters effectively.

Cluster ManagementControllerDistributed Systems
0 likes · 27 min read
Unveiling Kafka’s Controller: Architecture, Election, and Monitoring Deep Dive
Java Tech Enthusiast
Java Tech Enthusiast
Oct 8, 2021 · Backend Development

How to Share Session Across Distributed SpringBoot Services with Redis and Spring Session

This article walks through the challenges of sharing HTTP session data between micro‑services in a distributed SpringBoot architecture, demonstrates a Redis‑based manual solution, introduces Spring Session for transparent session clustering, and resolves OpenFeign cookie loss with a request interceptor.

Distributed SystemsOpenFeignRedis
0 likes · 12 min read
How to Share Session Across Distributed SpringBoot Services with Redis and Spring Session
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.

ActiveMQDistributed SystemsKafka
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.

CerberusDistributed SystemsGTIS
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 PatternsDistributed SystemsSoftware Architecture
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.

ConcurrencyDistributed SystemsRate Limiting
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.

ConsistencyDistributed SystemsLease
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.

Distributed SystemsUAVcontrol 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 ComputingDistributed Systems
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.

Distributed SystemsDubboNetty
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.

BackendDistributed SystemsRedis
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.

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

Distributed SystemsSessionTomcat
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.

Backend DevelopmentDistributed SystemsDubbo
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.

CachingDistributed SystemsMessage queue
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.

Distributed SystemsExactly-OnceIdempotence
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 SystemsScalabilityload balancing
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.

Best PracticesDesign PrinciplesDistributed Systems
0 likes · 12 min read
30 Proven Architecture Principles Every Software Engineer Should Follow