BestHub
Sign in
Tagged articles

distributed systems

2274 articles · Page 14 of 23
HelloTech
HelloTech
May 9, 2021 · Cloud Native

Distributed Message Governance and Microservice High‑Availability Practices

The guide details how to build a distributed message‑governance platform for the Hello mobility service, covering unified SDK design, RocketMQ pitfalls, client and cluster health monitoring, risk mitigation, and a tiered microservice high‑availability architecture that uses circuit‑breaking, rate‑limiting, and pre‑heating to ensure resilient traffic handling.

Message QueueRocketMQdistributed systems
0 likes · 14 min read
Distributed Message Governance and Microservice High‑Availability Practices
Top Architect
Top Architect
May 9, 2021 · Backend Development

Understanding Message Queues: From Redis List to Kafka and Pulsar Architecture

This article explains the evolution of message‑queue middleware by comparing basic double‑ended queue implementations, Redis list usage, Kafka’s partitioned log design with cursor‑based consumption and high‑availability replication, and Pulsar’s compute‑storage separation using BookKeeper, while highlighting their strengths, limitations, and practical trade‑offs.

Pulsardistributed systems
0 likes · 30 min read
Understanding Message Queues: From Redis List to Kafka and Pulsar Architecture
macrozheng
macrozheng
May 8, 2021 · Big Data

Why Kafka 2.8 Drops Zookeeper: Architecture, Challenges, and KIP‑500

This article explains how Kafka 2.8 removes its dependency on Zookeeper, describes Kafka's core concepts and its interaction with Zookeeper, outlines the role of the Controller, discusses operational complexities and upgrade paths with KIP‑500, and highlights the benefits of the new KRaft‑based architecture.

KIP-500KRaftKafka
0 likes · 10 min read
Why Kafka 2.8 Drops Zookeeper: Architecture, Challenges, and KIP‑500
Open Source Linux
Open Source Linux
May 8, 2021 · Fundamentals

Why Understanding Software Architecture Evolution Matters for Developers

This article outlines the evolution of software architecture—from monolithic to distributed, microservice, and serverless models—detailing each pattern’s structure, advantages, and drawbacks, helping developers understand how architectural choices impact scalability, maintenance, and innovation in modern software projects.

Serverlessdistributed systemsmaintenance
0 likes · 12 min read
Why Understanding Software Architecture Evolution Matters for Developers
Top Architect
Top Architect
May 7, 2021 · Backend Development

Evolution of Taobao Backend Architecture: From Single‑Server Deployment to Cloud‑Native Microservices

This article uses Taobao's backend as a case study to illustrate how a system evolves from a single‑server setup to a highly available, horizontally scalable architecture through stages such as separating Tomcat and database, adding caching, introducing load balancers, read/write splitting, sharding, microservices, ESB, containerization, and finally cloud‑native deployment, while summarizing key design principles.

Cloud Computingdistributed systemsscalability
0 likes · 18 min read
Evolution of Taobao Backend Architecture: From Single‑Server Deployment to Cloud‑Native Microservices
Dada Group Technology
Dada Group Technology
May 7, 2021 · Operations

How JD Daojia Built a Scalable Load‑Testing Platform to Reduce Test Time to 15 Minutes

Facing rising traffic, JD Daojia’s in‑house load‑testing platform was redesigned to automate script management, enable distributed JMeter execution, integrate real‑time monitoring, and support custom RPC protocols, dramatically lowering manual effort, cutting test cycles from an hour to fifteen minutes while ensuring system stability.

JMeterLoad Testingautomation
0 likes · 12 min read
How JD Daojia Built a Scalable Load‑Testing Platform to Reduce Test Time to 15 Minutes
Code Ape Tech Column
Code Ape Tech Column
May 7, 2021 · Industry Insights

How to Design a Scalable, High‑Performance Distributed E‑Commerce Architecture

This article provides a comprehensive technical overview of large‑scale distributed website architecture, covering characteristics, goals, common patterns, high‑performance and high‑availability designs, scalability, extensibility, security, agility, a seven‑layer reference model, and the evolutionary steps of modern e‑commerce systems.

Cachingdatabase shardingdistributed systems
0 likes · 26 min read
How to Design a Scalable, High‑Performance Distributed E‑Commerce Architecture
IT Architects Alliance
IT Architects Alliance
May 6, 2021 · Industry Insights

Designing High‑Performance, Highly‑Available Large‑Scale Web Architectures

This article provides a comprehensive technical overview of large‑scale distributed website architecture, covering characteristics, goals, common patterns, high‑performance and high‑availability designs, scalability, extensibility, security, agility, a seven‑layer reference model, and a detailed e‑commerce case study with practical optimization steps.

Cachingdistributed systemse-commerce
0 likes · 26 min read
Designing High‑Performance, Highly‑Available Large‑Scale Web Architectures
DataFunTalk
DataFunTalk
May 5, 2021 · Big Data

JD's OLAP Architecture: Design, Challenges, and Solutions

This article explains how JD constructs its OLAP platform from data ingestion to storage, querying, and management, describing the diverse data sources, real‑time and offline processing, scalability, consistency, fault tolerance, and future optimization plans, while addressing key technical challenges and solutions.

JD.comOLAPbig data
0 likes · 15 min read
JD's OLAP Architecture: Design, Challenges, and Solutions
Top Architect
Top Architect
May 5, 2021 · Backend Development

Technical Summary of Large-Scale Distributed Website Architecture

This article provides a comprehensive technical overview of large-scale distributed website architecture, covering characteristics, design goals, layered patterns, performance and high‑availability optimizations, scalability, extensibility, security measures, agile practices, and the evolutionary steps of e‑commerce systems.

distributed systemsscalability
0 likes · 22 min read
Technical Summary of Large-Scale Distributed Website Architecture
Architecture Digest
Architecture Digest
May 5, 2021 · Backend Development

Technical Summary of Large‑Scale Distributed Website Architecture

The article presents a comprehensive overview of large‑scale distributed website architecture, detailing its characteristics, performance and availability goals, layered design patterns, high‑performance and high‑availability techniques, scalability, extensibility, security, and practical e‑commerce case studies.

distributed systemse-commerceload balancing
0 likes · 23 min read
Technical Summary of Large‑Scale Distributed Website Architecture
Architect
Architect
May 1, 2021 · Backend Development

Technical Summary of Large‑Scale Distributed Website Architecture

This article provides a comprehensive technical overview of large‑scale distributed website architecture, covering characteristics, design goals, high‑performance, high‑availability, scalability, security, and detailed patterns such as layered design, caching, clustering, load balancing, database sharding, CDN, and service‑oriented decomposition.

Cachingdistributed systemshigh availability
0 likes · 23 min read
Technical Summary of Large‑Scale Distributed Website Architecture
Java Interview Crash Guide
Java Interview Crash Guide
Apr 30, 2021 · Operations

How Do Large Internet Companies Achieve Cross‑Region Multi‑Active High Availability?

The article explains why large internet firms adopt cross‑region multi‑active architectures for high availability, compares cold backup, hot standby, same‑city active‑active, and cross‑region active‑active solutions, discusses their trade‑offs, and presents practical design patterns and questions for implementing such systems.

Multi-Activedisaster recoverydistributed systems
0 likes · 15 min read
How Do Large Internet Companies Achieve Cross‑Region Multi‑Active High Availability?
vivo Internet Technology
vivo Internet Technology
Apr 28, 2021 · Backend Development

Tars Java RPC Client Design and Implementation Analysis

The article thoroughly examines Tars’s Java RPC client, explaining its initialization, proxy generation via JDK dynamic proxies, diverse load‑balancing strategies, NIO‑based Reactor networking, and both synchronous (CountDownLatch) and asynchronous callback mechanisms, supplemented with detailed source‑code illustrations of each component.

Client DesignNIO SelectorRPC Framework
0 likes · 15 min read
Tars Java RPC Client Design and Implementation Analysis
IT Architects Alliance
IT Architects Alliance
Apr 26, 2021 · Backend Development

How Ctrip Built Hermes: A Deep Dive into Scalable Message Queue Architecture

This article examines Ctrip’s Hermes messaging system, tracing its evolution from a simple Mongo‑based queue to a broker‑centric, MySQL/Kafka hybrid architecture, and explains the design choices, performance optimizations, cluster management via lease‑based meta‑server, and lessons learned for building high‑throughput, low‑latency MQ solutions.

CtripHermesMessage Queue
0 likes · 22 min read
How Ctrip Built Hermes: A Deep Dive into Scalable Message Queue Architecture
Java High-Performance Architecture
Java High-Performance Architecture
Apr 26, 2021 · Fundamentals

Visualizing Kafka: Core Concepts Explained with Diagrams

This article provides a visual walkthrough of Kafka's fundamental concepts—including producers, consumers, topics, partitions, and cluster architecture—illustrated with diagrams to help readers clearly understand how messages flow and are stored in a distributed streaming system.

KafkaMessage Streamingconsumer groups
0 likes · 6 min read
Visualizing Kafka: Core Concepts Explained with Diagrams
Top Architect
Top Architect
Apr 24, 2021 · Fundamentals

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

This article provides a comprehensive overview of distributed system fundamentals, covering node models, replica concepts, various consistency levels, data distribution strategies, lease-based caching, quorum mechanisms, two‑phase commit, MVCC, Paxos consensus, and the CAP theorem, illustrating each with practical examples and diagrams.

CAP theoremConsensusConsistency
0 likes · 54 min read
Fundamentals of Distributed Systems: Models, Replication, Consistency, and Core Protocols
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 23, 2021 · Big Data

Mastering Elasticsearch: Core Concepts, Architecture, and Performance Tips

This comprehensive guide explains Elasticsearch’s fundamentals, including its distributed architecture, indexing process, shard and replica mechanisms, query execution, near‑real‑time search, segment management, and practical optimization techniques, providing developers and engineers with the knowledge needed to design, operate, and troubleshoot large‑scale search clusters.

Near Real-Timedistributed systemsindexing
0 likes · 71 min read
Mastering Elasticsearch: Core Concepts, Architecture, and Performance Tips
Laravel Tech Community
Laravel Tech Community
Apr 22, 2021 · Big Data

Apache Kafka 2.8.0 Release Highlights and New Features

Apache Kafka 2.8.0 introduces several significant enhancements, including a new group API, mutual TLS authentication for SASL_SSL listeners, JSON request/response logging, broker connection rate limiting, topic identifiers, self‑managed quorum replacing ZooKeeper, and numerous improvements to Streams and Connect APIs for more reliable real‑time data pipelines.

Apache KafkaKafka 2.8.0Real-time Data
0 likes · 2 min read
Apache Kafka 2.8.0 Release Highlights and New Features
dbaplus Community
dbaplus Community
Apr 22, 2021 · Operations

Achieving True Multi‑Region Active‑Active: Bidirectional Sync Across Three Data Centers

This article explains how to implement a true multi‑region active‑active architecture by enabling bidirectional data synchronization among three or more data centers, covering CAP trade‑offs, distributed ID generation algorithms, center closure strategies, final consistency mechanisms, and a disaster‑recovery design.

CAP theoremdata synchronizationdisaster recovery
0 likes · 16 min read
Achieving True Multi‑Region Active‑Active: Bidirectional Sync Across Three Data Centers
Tencent Cloud Middleware
Tencent Cloud Middleware
Apr 21, 2021 · Backend Development

How Pulsar Stores Messages and How BookKeeper’s GC Keeps Them Clean

This article explains Apache Pulsar’s message storage architecture in BookKeeper, details the ledger and entry lifecycle, describes the multi‑layer caching read path, and outlines BookKeeper’s garbage‑collection process along with practical operational tips for avoiding disk‑heavy scenarios.

Apache PulsarBackendBookKeeper
0 likes · 12 min read
How Pulsar Stores Messages and How BookKeeper’s GC Keeps Them Clean
HomeTech
HomeTech
Apr 21, 2021 · Artificial Intelligence

AI-Powered Masked Danmaku: Design and Implementation

This article details the design and practical implementation of an AI-driven masked danmaku system that prevents comment overlay on video content, covering background, technology selection, instance segmentation methods, distributed task scheduling, mask generation, client rendering, performance optimizations, and future directions.

AIMask DanmakuVideo Processing
0 likes · 18 min read
AI-Powered Masked Danmaku: Design and Implementation
Big Data Technology & Architecture
Big Data Technology & Architecture
Apr 20, 2021 · Fundamentals

Consistent Hashing and Jump Consistent Hash: Concepts, Implementation, and Use Cases

This article explains the fundamentals of consistent hashing, compares the classic ring‑based method with the more efficient jump consistent hash algorithm, provides reference implementations in C++, discusses their time‑complexity and practical trade‑offs, and shows how they are applied in systems such as Greenplum.

Greenplumalgorithmconsistent hashing
0 likes · 11 min read
Consistent Hashing and Jump Consistent Hash: Concepts, Implementation, and Use Cases
Java Interview Crash Guide
Java Interview Crash Guide
Apr 19, 2021 · Fundamentals

What You Need to Know About Distributed Systems: Theory, Consistency, Transactions & Redis

This comprehensive guide covers the core concepts of distributed systems—including CAP theory, consistency models, transaction protocols like 2PC/3PC and TCC, Redis features, persistence options, expiration strategies, memory eviction policies, distributed locking with Redis and Zookeeper, as well as an overview of Kafka's architecture and reliability mechanisms.

ConsistencyMessage QueueRedis
0 likes · 34 min read
What You Need to Know About Distributed Systems: Theory, Consistency, Transactions & Redis
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 19, 2021 · Backend Development

Mastering Distributed Systems: CAP, Redis, Zookeeper, Kafka and More

This comprehensive guide covers core distributed system theories, CAP consistency, transaction protocols, Redis features and persistence, Zookeeper coordination, message queue fundamentals, Kafka performance tricks, and practical solutions for caching, locking, and high‑concurrency scenarios.

KafkaRedisZooKeeper
0 likes · 34 min read
Mastering Distributed Systems: CAP, Redis, Zookeeper, Kafka and More
IT Architects Alliance
IT Architects Alliance
Apr 18, 2021 · Backend Development

Microservice Architecture and Its 10 Most Important Design Patterns

This article explains microservice architecture, its key characteristics, advantages and disadvantages, and presents 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—while offering guidance on when to apply each pattern.

Design Patternsbackend architecturedistributed systems
0 likes · 26 min read
Microservice Architecture and Its 10 Most Important Design Patterns
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 16, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Backend Engineer Should Know

This comprehensive guide explains microservice architecture, its key characteristics, advantages, disadvantages, and when to adopt it, then details ten crucial design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—complete with pros, cons, use‑cases, and technology examples.

API GatewayDesign Patternsbackend architecture
0 likes · 36 min read
10 Essential Microservice Design Patterns Every Backend Engineer Should Know
Tencent Cloud Developer
Tencent Cloud Developer
Apr 14, 2021 · Cloud Native

Apache Pulsar Meetup Shenzhen: Cloud-Native Distributed Messaging and Streaming Platform

The Apache Pulsar Meetup in Shenzhen on April 17, 2021, co‑hosted by Tencent Middleware and StreamNative, will showcase Pulsar’s cloud‑native messaging, streaming, and storage capabilities through sessions on KoP migration, big‑data and IoT use cases, cloud‑native deployments, and the StreamNative Cloud Pulsar‑as‑a‑Service offering.

Apache PulsarMeetupcloud-native
0 likes · 7 min read
Apache Pulsar Meetup Shenzhen: Cloud-Native Distributed Messaging and Streaming Platform
Java Interview Crash Guide
Java Interview Crash Guide
Apr 14, 2021 · Backend Development

Choosing the Right Globally Unique ID Strategy: From Auto‑Increment to Snowflake

This article compares common globally unique ID generation methods—including database auto‑increment, batch services, UUID/GUID, timestamp‑based IDs, Redis INCR, and Twitter’s Snowflake—detailing their advantages, drawbacks, and improvement options to help developers select the most suitable approach for scalability and ordering needs.

Redisdistributed systemsglobal ID
0 likes · 14 min read
Choosing the Right Globally Unique ID Strategy: From Auto‑Increment to Snowflake
21CTO
21CTO
Apr 13, 2021 · Fundamentals

Choosing the Right Architecture: Monolith, Distributed, Microservices, and Serverless

Software developers need to understand the evolution of software architectures—from simple monolithic designs to distributed applications, microservices, and serverless platforms—because each model has distinct advantages and drawbacks that affect scalability, maintainability, deployment frequency, operational complexity, and overall cost.

distributed systemsmicroservicesmonolithic
0 likes · 13 min read
Choosing the Right Architecture: Monolith, Distributed, Microservices, and Serverless
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 13, 2021 · Big Data

Kafka Architecture and Implementation Principles – Theory Part

This article provides a comprehensive, diagram‑driven explanation of Kafka’s architecture, covering producers, consumers, topics, partitions, replication, Zookeeper coordination, controller election, state machines, and the NIO‑based network model, helping readers understand the design philosophy and practical configuration implications.

ControllerReplicationZooKeeper
0 likes · 15 min read
Kafka Architecture and Implementation Principles – Theory Part
Selected Java Interview Questions
Selected Java Interview Questions
Apr 12, 2021 · Backend Development

Zookeeper Command Reference and Node Management Guide

This article provides a comprehensive tutorial on Zookeeper 3.5.10, covering client and server commands, node attributes, creation, querying, updating, deletion, listing children, checking node status, watcher usage, and detailed access control mechanisms with practical command examples.

CLINode ManagementZooKeeper
0 likes · 14 min read
Zookeeper Command Reference and Node Management Guide
Big Data Technology Architecture
Big Data Technology Architecture
Apr 11, 2021 · Big Data

Apache Kafka 2.8 Introduces KRaft: Running Without ZooKeeper

Apache Kafka 2.8 replaces ZooKeeper with an internal Quorum controller (KRaft), enabling ZooKeeper‑free operation, reducing resource usage, improving performance, and supporting larger clusters while noting that early versions lack some security and management features and are not yet production‑ready.

ZooKeeperdistributed systems
0 likes · 4 min read
Apache Kafka 2.8 Introduces KRaft: Running Without ZooKeeper
Code Ape Tech Column
Code Ape Tech Column
Apr 9, 2021 · Backend Development

Comprehensive Comparison of Kafka, RabbitMQ, RocketMQ, and ActiveMQ Across 17 Dimensions

This article provides a detailed side‑by‑side analysis of four major distributed message‑queue systems—Kafka, RabbitMQ, RocketMQ, and ActiveMQ—examining them across seventeen criteria such as documentation, language support, protocols, storage, transactions, load balancing, clustering, management UI, availability, duplication, throughput, subscription models, ordering, acknowledgments, replay, retry, and concurrency.

ActiveMQKafkaMessage Queue
0 likes · 22 min read
Comprehensive Comparison of Kafka, RabbitMQ, RocketMQ, and ActiveMQ Across 17 Dimensions
JD Tech
JD Tech
Apr 8, 2021 · Artificial Intelligence

Federated Learning in E‑commerce Marketing: JD.com’s 9N‑FL Platform Overview and Practices

This article explains how data islands hinder AI progress, introduces federated learning as a privacy‑preserving solution, details JD.com’s 9N‑FL platform—including its architecture, features, classification, privacy‑preserving techniques, and algorithm support—and demonstrates its successful application in e‑commerce advertising that yielded over 15% revenue growth.

AIdistributed systemsfederated learning
0 likes · 12 min read
Federated Learning in E‑commerce Marketing: JD.com’s 9N‑FL Platform Overview and Practices
Baidu Geek Talk
Baidu Geek Talk
Apr 7, 2021 · Backend Development

Design and Architecture of Baidu Transaction Middle Platform Order System

Baidu’s Transaction Middle Platform Order System provides a unified, cloud‑native architecture that supports diverse Baidu products by orchestrating modular commands, handling order lifecycle, payment, refunds, and splitting, while employing caching, asynchronous processing, and sharded databases to achieve high throughput and low latency.

backend architecturecommand orchestrationdistributed systems
0 likes · 16 min read
Design and Architecture of Baidu Transaction Middle Platform Order System
IT Architects Alliance
IT Architects Alliance
Apr 5, 2021 · Operations

Design and Implementation of a Handcrafted Distributed Cluster (MyCluster)

This article describes how to design and build a native distributed cluster called MyCluster without using any existing frameworks, covering master‑slave architecture, leader election, split‑brain handling, centralized configuration management, custom communication protocols, state transitions, and client interfaces.

Leader Electioncluster architectureconfiguration management
0 likes · 13 min read
Design and Implementation of a Handcrafted Distributed Cluster (MyCluster)
Architecture Digest
Architecture Digest
Apr 3, 2021 · Backend Development

Evolution of Software Architecture: Monolithic, Distributed, Microservices, and Serverless

The article explains the progression of software architecture from simple monolithic designs through distributed applications and microservices to modern serverless solutions, outlining each model's structure, advantages, disadvantages, and impact on development and operations for software engineers.

Serverlessdistributed systemsmonolithic
0 likes · 11 min read
Evolution of Software Architecture: Monolithic, Distributed, Microservices, and Serverless
Architecture Digest
Architecture Digest
Apr 2, 2021 · Backend Development

Understanding the Essence of Architecture: A Deep Dive into Weibo’s Large‑Scale System Design

The article explores the fundamental concepts of software architecture, illustrating how massive platforms like Weibo handle millions of users through layered design, service decomposition, multi‑level caching, distributed tracing, and capacity planning to achieve high scalability and reliability.

Backendarchitecturedistributed systems
0 likes · 21 min read
Understanding the Essence of Architecture: A Deep Dive into Weibo’s Large‑Scale System Design
Meituan Technology Team
Meituan Technology Team
Apr 1, 2021 · Databases

Meituan's Graph Database Selection and Platform Construction

Meituan evaluated open‑source distributed graph databases against strict latency, scale, and import criteria, selected NebulaGraph for its superior multi‑hop query and bulk‑load performance, and built a four‑layer, highly available platform that ingests petabyte‑scale data in real time, supports diverse business use cases, and provides interactive visualization.

Data IngestionNebulaGraphdistributed systems
0 likes · 21 min read
Meituan's Graph Database Selection and Platform Construction
Ops Development Stories
Ops Development Stories
Apr 1, 2021 · Operations

Zookeeper Leader Election Explained: Cluster Architecture & Code Walkthrough

This article provides a comprehensive overview of Zookeeper's cluster deployment, explains the four server states, details the leader election process—including initialization, voting, and decision logic—and presents key source code snippets to help developers understand and implement Zookeeper's high‑availability mechanisms.

JavaLeader ElectionZooKeeper
0 likes · 10 min read
Zookeeper Leader Election Explained: Cluster Architecture & Code Walkthrough
NiuNiu MaTe
NiuNiu MaTe
Mar 31, 2021 · Backend Development

How to Ensure Reliable Service‑to‑Service Messaging: 5 Proven Retry Strategies

This article explores why reliable inter‑service communication is essential in microservice architectures, illustrates common pitfalls with real‑world examples, and presents five practical retry and persistence solutions—including fast retry, in‑memory queues, persistent queues, retry services, and pre‑notification—to improve message delivery reliability.

Message Queuebackend reliabilitydistributed systems
0 likes · 11 min read
How to Ensure Reliable Service‑to‑Service Messaging: 5 Proven Retry Strategies
Architects Research Society
Architects Research Society
Mar 29, 2021 · Operations

eBay’s Scalability Best Practices: Functional Partitioning, Horizontal Sharding, Asynchronous Decoupling, and More

The article outlines eBay’s practical scalability principles—including functional partitioning, horizontal sharding, avoiding distributed transactions, aggressive asynchronous decoupling, moving work to async pipelines, virtualization, and intelligent caching—demonstrating how large‑scale web systems can be designed for linear growth and high availability.

Cachingasynchronousdistributed systems
0 likes · 14 min read
eBay’s Scalability Best Practices: Functional Partitioning, Horizontal Sharding, Asynchronous Decoupling, and More
Sohu Tech Products
Sohu Tech Products
Mar 24, 2021 · Backend Development

The Essence of Architecture: Insights from Large‑Scale Systems like Weibo

This article explores the fundamental principles of system architecture, illustrating how large‑scale services such as Uber and Weibo handle massive traffic through strategic abstraction, modularization, performance optimization, multi‑level caching, distributed tracing, and operational best practices to achieve scalability and reliability.

Cachingarchitecturedistributed systems
0 likes · 21 min read
The Essence of Architecture: Insights from Large‑Scale Systems like Weibo
Tencent Cloud Developer
Tencent Cloud Developer
Mar 24, 2021 · Cloud Native

Understanding Microservice Orchestration with Zeebe: Architecture, Features, and Implementation

The article explains how Zeebe, a cloud‑native workflow engine, orchestrates microservices by separating task logic from coordination, detailing its BPMN‑based architecture (client, gateway, brokers, exporters), core features such as real‑time visibility, horizontal scalability, fault tolerance, message‑driven processing, and showcases Java job‑worker code and benchmark results demonstrating tens of thousands of workflow instances per second.

JavaZeebecloud-native
0 likes · 22 min read
Understanding Microservice Orchestration with Zeebe: Architecture, Features, and Implementation
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.

Cachingdistributed systemshotspot 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 systemsfault tolerancehigh availability
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.

AWSCachingMemcached
0 likes · 16 min read
Scaling Cache Infrastructure at Pinterest
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.

AIHigh ConcurrencyMeituan
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.

Hot RestartService Governancedistributed systems
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.

AIOpsai-optimizationdistributed systems
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.

Hot RestartOCTO 2.0Service Governance
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
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.

ChatroomHyperLogLogdistributed systems
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.

BackendScalable DesignWeibo
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.

JavaRule EngineTag Management
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-entropydata replicationdistributed systems
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.

DockerJava Clientdistributed systems
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 theoremOceanBasedatabase sharding
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 theoremLDC architectureOceanBase
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 PatternsHigh Concurrencycomponent integration
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.

Taobaoarchitecturecloud migration
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.

Exactly-OnceMessage IdempotencyRedis
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.

algorithmdistributed systemsgolang
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.

Remote Shuffle ServiceShuffle OptimizationSpark
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.

data synchronizationdisaster recoverydistributed systems
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.

Message Queuebig datadistributed systems
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.

Object Storageblock storagecloud native
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.

algorithmdistributed systems
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.

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

High Concurrencybackend architecturecloud native
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.

CachingKafkaMessage 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 integerDomain-Driven DesignSQL Server
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.

Cluster OperationsKafkadistributed systems
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.

BackendDesign Patternsarchitecture
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.

Message Queuebig datadistributed systems
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 governancedata security
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 PerformanceCachingcache 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.

JavaRPCSPI
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 AvalancheCaching
0 likes · 9 min read
Mastering Cache Strategies: Prevent Database Bottlenecks in High‑Traffic Systems