BestHub
Sign in
Tagged articles
2124 articles
Page 11 of 22
Top Architect
Top Architect
Sep 18, 2021 · Backend Development

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

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

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

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

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

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

Message Deduplication and Exactly-Once Semantics in RocketMQ

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

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

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

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

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

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

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

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

Why RocketMQ Solves Core Messaging Challenges – Architecture and Features Explained

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

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

RocketMQ NameServer Architecture Design and Source Code Analysis

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Circuit BreakerConcurrency ControlDistributed Systems
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Strategies, and Real-World Implementations
IT Architects Alliance
IT Architects Alliance
Sep 11, 2021 · Backend Development

Technical Summary of Large-Scale Distributed Website Architecture

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

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

Design and Advantages of a Cloud‑Native ClickHouse OLAP System

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

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

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

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

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

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

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

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

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

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

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

Overview of Dubbo Layered Architecture and Design

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

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

Cloud‑Native ClickHouse Architecture and Design Overview

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

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

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

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

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

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

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

Distributed SystemsJD ForceBothigh-fidelity testing
0 likes · 8 min read
High-Fidelity Load Testing: Practices and Technical Innovations from JD's ForceBot Platform
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 3, 2021 · Backend Development

Distributed Real-Time Local Cache Practice in iQIYI TV Backend

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

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

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

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

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

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

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

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

Rate Limiting Strategies, Algorithms, and Implementations in Backend Systems

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

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

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

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

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

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

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

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

How to Achieve Exactly-Once Message Processing with RocketMQ Deduplication

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

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

What the Two‑Generals Problem Reveals About Distributed Transactions

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

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

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

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

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

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

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

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

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

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

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

Mastering Cookies vs. Sessions: Deep Dive for Web Interviews

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

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

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

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

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

Mastering Cache Strategies: From CDN to Distributed Systems

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

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

High Availability Practices: From Taobao to Cloud Migration

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

AlibabaDistributed Systemscloud architecture
0 likes · 19 min read
High Availability Practices: From Taobao to Cloud Migration
Tencent Cloud Developer
Tencent Cloud Developer
Aug 19, 2021 · Backend Development

Message Queue Design Principles and Implementation Analysis

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

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

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

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

Distributed Systemscapacity planningcloud scaling
0 likes · 23 min read
How Alibaba Conquered Double 11: Scaling to 17.5k TPS with High‑Availability Architecture
IT Architects Alliance
IT Architects Alliance
Aug 17, 2021 · Backend Development

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

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

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

How Meituan Scaled Instant Logistics with Distributed Systems and AI

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

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

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

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

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

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

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

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

Understanding HBase HLog and Fault Recovery Mechanisms

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

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

Database Disaster Recovery Technologies for the Financial Sector

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

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

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

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

BackendDistributed SystemsRedis
0 likes · 6 min read
How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis, and Cookie Solutions
IT Architects Alliance
IT Architects Alliance
Aug 9, 2021 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Practical Guava & Nginx Implementations

This article explains why rate limiting is essential for system stability, compares it with caching and degradation, details three core algorithms—counter, leaky bucket, and token bucket—and provides concrete Guava, Java, and Nginx + Lua code examples for implementing both local and distributed throttling.

BackendDistributed SystemsGuava
0 likes · 14 min read
Mastering Rate Limiting: Algorithms, Strategies, and Practical Guava & Nginx Implementations
Efficient Ops
Efficient Ops
Aug 9, 2021 · Operations

Why “High Availability” Often Fails: Lessons from a Messaging System Disaster

A real‑world incident with ActiveMQ’s high‑availability setup shows that focusing on component reliability without business‑level capacity planning, monitoring, and graceful degradation can cripple services, highlighting that true high availability must prioritize overall system and user experience.

Distributed SystemsReliabilitymessaging queues
0 likes · 7 min read
Why “High Availability” Often Fails: Lessons from a Messaging System Disaster
php Courses
php Courses
Aug 9, 2021 · Databases

Interview Transcript: MySQL, Redis, PHP, and Distributed Systems Questions

The article records a video interview where the candidate answers technical questions on MySQL isolation levels, InnoDB indexing, locking, distributed locks, Redis sharding, PHP‑FPM architecture, RabbitMQ, AOP, Hyperf, and other backend topics, reflecting on the challenges faced during the session.

BackendDatabasesDistributed Systems
0 likes · 7 min read
Interview Transcript: MySQL, Redis, PHP, and Distributed Systems Questions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 8, 2021 · Backend Development

Mastering Message Exchange Patterns: From Pub/Sub to Anycast

This article explains the fundamental message exchange architectures and routing patterns—including publish‑subscribe, fan‑out, unidirectional and bidirectional streaming, as well as unicast, broadcast, multicast, and anycast—illustrated with diagrams and practical examples for modern backend systems.

BackendDistributed SystemsMessaging
0 likes · 9 min read
Mastering Message Exchange Patterns: From Pub/Sub to Anycast
Java Tech Enthusiast
Java Tech Enthusiast
Aug 7, 2021 · Backend Development

Cache Optimization and Distributed Locking in High-Concurrency Systems

By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.

Cache ConsistencyCachingDistributed Systems
0 likes · 16 min read
Cache Optimization and Distributed Locking in High-Concurrency Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 3, 2021 · Big Data

How Hera Transforms Vipshop’s Data Service for Scalable E‑Commerce Analytics

This article explains how Vipshop built the Hera data service since 2019 to provide a unified API for warehouse access, detailing its background, architecture, core features such as multi‑engine queries, adaptive execution, custom Lisp syntax, task scheduling, metrics collection, and performance gains for both B‑to‑B and B‑to‑C workloads.

Data ServiceDistributed SystemsLisp
0 likes · 21 min read
How Hera Transforms Vipshop’s Data Service for Scalable E‑Commerce Analytics
Programmer DD
Programmer DD
Aug 2, 2021 · Backend Development

High Availability for Elastic Job Lite: Active‑Standby and Dual‑Data‑Center Design

This article explains how to transform single‑node Elastic Job Lite deployments into highly available solutions, covering Zookeeper‑based sharding, active‑standby strategies for dual‑data‑center setups, custom sharding implementations, and priority scheduling to ensure tasks run reliably across both primary and backup sites.

Distributed SystemsElastic-JobJob Scheduling
0 likes · 14 min read
High Availability for Elastic Job Lite: Active‑Standby and Dual‑Data‑Center Design
IT Architects Alliance
IT Architects Alliance
Aug 1, 2021 · Backend Development

Design and Architecture of a Cloud Shopping Cart System

This article explains the design and architecture of a cloud-based shopping cart system, covering its functional modules, layered and cluster designs, distributed goals such as stability and elasticity, three-level caching, asynchronous checks, heterogeneous storage, payment solutions, and anti‑scalping measures.

Backend DevelopmentCachingDistributed Systems
0 likes · 5 min read
Design and Architecture of a Cloud Shopping Cart System
Senior Brother's Insights
Senior Brother's Insights
Jul 28, 2021 · Operations

How Zookeeper Prevents Split‑Brain: Inside Quorum‑Based Leader Election

This article explains the split‑brain phenomenon in distributed clusters, uses Zookeeper as a case study to illustrate how network partitions can create multiple leaders, and details Zookeeper's majority‑quorum mechanism, node count considerations, and common strategies for avoiding split‑brain scenarios.

Cluster ManagementDistributed SystemsSplit-Brain
0 likes · 13 min read
How Zookeeper Prevents Split‑Brain: Inside Quorum‑Based Leader Election
Java Interview Crash Guide
Java Interview Crash Guide
Jul 28, 2021 · Backend Development

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

This article explains why session sharing is needed in micro‑service architectures, outlines common Nginx reverse‑proxy strategies, and presents four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis centralized cache, and cookie‑based sharing—detailing their implementations and trade‑offs.

Distributed SystemsRedisTomcat
0 likes · 6 min read
How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis & Cookie Solutions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 25, 2021 · Backend Development

Mastering Microservices: A Visual Guide to Spring Cloud Architecture

This article presents a comprehensive visual overview of microservice concepts and architecture evolution, detailing the transition from monolithic to SOA and microservice styles, and introduces Spring Cloud’s core components—including Eureka, Ribbon, Feign, Hystrix, Zuul, Gateway, Config, Bus, OAuth2, and Sleuth—illustrated with 19 mind‑map diagrams.

BackendDistributed Systemsarchitecture
0 likes · 8 min read
Mastering Microservices: A Visual Guide to Spring Cloud Architecture
IT Architects Alliance
IT Architects Alliance
Jul 25, 2021 · Backend Development

Evolution of Microservice Architecture and Its Essential Technology Stack

This article traces the historical development of microservice architecture from monolithic to distributed services, outlines its advantages and drawbacks, and presents a comprehensive technology stack—including service communication, API gateways, authentication, fault tolerance, logging, configuration, containerization, orchestration, and CI/CD—to guide practitioners in building robust, scalable backend systems.

BackendContainerizationDistributed Systems
0 likes · 16 min read
Evolution of Microservice Architecture and Its Essential Technology Stack
IT Architects Alliance
IT Architects Alliance
Jul 25, 2021 · Fundamentals

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

This article provides a comprehensive overview of distributed system fundamentals, covering concepts such as nodes, replicas, consistency models, data distribution strategies, lease and quorum mechanisms, two‑phase commit, MVCC, Paxos, and the CAP theorem, while discussing their practical engineering trade‑offs and failure handling.

CAP theoremConsistencyDistributed Systems
0 likes · 54 min read
Fundamentals of Distributed Systems: Concepts, Replication, Consistency, and Core Protocols
IT Architects Alliance
IT Architects Alliance
Jul 24, 2021 · Backend Development

Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation

The article introduces Youzan's Transparent Multilevel Cache (TMC), detailing its three‑layer architecture, hotspot detection and local caching mechanisms, integration approaches for Java applications, stability and consistency features, and performance results from real‑world e‑commerce campaigns.

CacheDistributed SystemsLocal Cache
0 likes · 13 min read
Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation
Architects' Tech Alliance
Architects' Tech Alliance
Jul 21, 2021 · Cloud Computing

What Is Edge Computing? Key Concepts, Architectures, and Future Trends

Edge computing, the latest computing paradigm beyond distributed, grid, and cloud models, integrates cloud, network, and intelligent edge devices to provide globally coordinated, low‑latency, intelligent services, and its various reference architectures—ETSI MEC, Intel MEC, ECC, and OpenFog—illustrate its resource‑centric, collaborative, and heterogeneous design.

Cloud ComputingDistributed SystemsFog Computing
0 likes · 11 min read
What Is Edge Computing? Key Concepts, Architectures, and Future Trends
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 21, 2021 · Backend Development

Designing a Scalable Business Middle Platform: Modeling, Service Principles, and Distributed Operations

This article explains how to abstract business functions into a middle platform through 0‑level and 1‑level modeling, defines domain capabilities and centers, outlines eight service design principles, and describes essential distributed mechanisms such as service registration, elastic scaling, rate limiting, gray release, messaging, and distributed transactions.

Backend DevelopmentDistributed Systemsbusiness architecture
0 likes · 17 min read
Designing a Scalable Business Middle Platform: Modeling, Service Principles, and Distributed Operations
IT Architects Alliance
IT Architects Alliance
Jul 19, 2021 · Backend Development

Design and Architecture of a Cloud‑Based Shopping Cart System

This article outlines the design principles, layered and cluster architecture, technical requirements, caching strategies, and payment integration of a cloud‑based shopping cart system, highlighting how distributed backend components ensure stability, high performance, elasticity, and anti‑fraud measures.

BackendDistributed SystemsShopping Cart
0 likes · 4 min read
Design and Architecture of a Cloud‑Based Shopping Cart System
Alibaba Cloud Native
Alibaba Cloud Native
Jul 19, 2021 · Operations

Scaling Distributed Observability: A Case Study of ARMS Front‑End Monitoring at a Kids Coding Platform

This article details how a rapidly growing Chinese children's programming platform tackled the complexity of distributed system observability by adopting SkyWalking, Prometheus, and Alibaba Cloud ARMS front‑end monitoring, achieving faster fault detection, reduced operational workload, and improved user experience.

ARMSDistributed SystemsObservability
0 likes · 12 min read
Scaling Distributed Observability: A Case Study of ARMS Front‑End Monitoring at a Kids Coding Platform
Open Source Linux
Open Source Linux
Jul 18, 2021 · Operations

Why a Single Kafka Broker Failure Can Halt All Consumers – The HA Explained

This article explains Kafka's high‑availability mechanisms, covering multi‑replica design, ISR synchronization, leader election, acknowledgment settings, and the hidden risk of the __consumer_offset topic's single‑replica configuration that can cause an entire cluster to become unavailable when one broker fails.

Distributed SystemsISRKafka
0 likes · 9 min read
Why a Single Kafka Broker Failure Can Halt All Consumers – The HA Explained
IT Architects Alliance
IT Architects Alliance
Jul 18, 2021 · Industry Insights

From Single Server to Cloud‑Native: 13 Steps to Scale High‑Concurrency Architecture

This article traces the evolution of a high‑concurrency backend architecture from a single‑machine setup to cloud‑native microservices, detailing ten‑plus stages such as separating Tomcat and DB, adding caches, load‑balancing with Nginx/LVS, read‑write splitting, sharding, containerization, and finally deploying on public cloud, while also summarizing key design principles.

BackendDistributed SystemsScalability
0 likes · 20 min read
From Single Server to Cloud‑Native: 13 Steps to Scale High‑Concurrency Architecture
Java Interview Crash Guide
Java Interview Crash Guide
Jul 17, 2021 · Backend Development

How Transparent Multilevel Cache (TMC) Boosts Performance with Hotspot Detection and Local Caching

The Transparent Multilevel Cache (TMC) solution adds application‑level hotspot detection, local caching, and hit‑rate statistics to a standard distributed cache stack, enabling automatic hotspot discovery, reducing load on backend cache clusters, and improving system stability and latency during traffic spikes.

CacheDistributed Systemshotspot detection
0 likes · 17 min read
How Transparent Multilevel Cache (TMC) Boosts Performance with Hotspot Detection and Local Caching
IT Architects Alliance
IT Architects Alliance
Jul 17, 2021 · Backend Development

Why Microservices Matter: Evolution, Challenges, and Best Practices

This article explains how microservices evolved from monolithic systems, compares them with SOA, discusses data fragmentation, CAP theory, distributed transactions, service partitioning, circuit breakers, API gateways, configuration management, tracing, and reviews popular frameworks like Spring Cloud and Dubbo.

CAP theoremCircuit BreakerDistributed Systems
0 likes · 14 min read
Why Microservices Matter: Evolution, Challenges, and Best Practices
Yuewen Technology
Yuewen Technology
Jul 16, 2021 · Operations

Mastering Log Aggregation: From LogID Generation to Powerful Analysis Tools

This article explores the challenges of log aggregation in micro‑service architectures, introduces a globally unique log identifier (logid) with its required properties, compares various logid generation schemes, and presents end‑to‑end solutions for log distribution, aggregation, and analysis using custom tools such as ylog and watcher.

Distributed Systemslog aggregationlog analysis
0 likes · 26 min read
Mastering Log Aggregation: From LogID Generation to Powerful Analysis Tools
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Jul 16, 2021 · Backend Development

How NetEase Cloud Scales to 10,000 Simultaneous Mic Connections: Backend Architecture Revealed

This article details NetEase Cloud's backend engineering solutions for supporting ten‑thousand‑user concurrent mic connections, covering distributed signaling architecture, QUIC‑based weak‑network handling, server‑side audio routing, video QoS strategies, and a global transmission network (WE‑CAN) to achieve high availability and scalability.

Distributed SystemsQoSWE-CAN
0 likes · 12 min read
How NetEase Cloud Scales to 10,000 Simultaneous Mic Connections: Backend Architecture Revealed
Youzan Coder
Youzan Coder
Jul 15, 2021 · Backend Development

Message Queue Architecture Comparison: NSQ, Kafka, and RocketMQ in Distributed Systems

The article compares the architectures of NSQ (YouZan branch), Kafka, and RocketMQ—detailing their coordination mechanisms, storage models, consistency guarantees, and operational trade‑offs—while recommending Kafka for log‑big‑data workloads, RocketMQ for massive topic counts, and NSQ for extensibility and lightweight deployment.

Distributed SystemsKafkaMessage queue
0 likes · 16 min read
Message Queue Architecture Comparison: NSQ, Kafka, and RocketMQ in Distributed Systems
TAL Education Technology
TAL Education Technology
Jul 15, 2021 · Backend Development

Design and Architecture of a Scalable Live‑Streaming Message Service

The article outlines the challenges of real‑time messaging in live‑streaming education, presents a multi‑stage backend architecture—including AccessServer, MessageServer, and specialized services—along with caching, clustering, and future enhancements such as connection migration and QUIC to achieve high reliability, low latency, and massive concurrency.

Backend ArchitectureDistributed SystemsScalability
0 likes · 12 min read
Design and Architecture of a Scalable Live‑Streaming Message Service
vivo Internet Technology
vivo Internet Technology
Jul 14, 2021 · Backend Development

Hystrix Source Code Analysis: Circuit Breaker, Isolation, and Fallback Mechanisms

Analyzing Hystrix’s source code reveals how its circuit‑breaker, bulkhead isolation (semaphore or thread‑pool), timeout detection, fallback logic, and sliding‑window health metrics work together to prevent cascading failures in distributed systems, as illustrated by an e‑commerce order service calling multiple downstream services.

Circuit BreakerDistributed SystemsHystrix
0 likes · 20 min read
Hystrix Source Code Analysis: Circuit Breaker, Isolation, and Fallback Mechanisms
Wukong Talks Architecture
Wukong Talks Architecture
Jul 14, 2021 · Operations

Understanding High Availability: Lessons from the Bilibili Outage

This article analyzes Bilibili's recent service disruption, explains the concept and quantitative metrics of high availability, and outlines practical techniques such as rate limiting, isolation, failover, timeout control, circuit breaking, degradation, and multi‑region active‑active deployments to improve system reliability.

Circuit BreakerDistributed SystemsHA
0 likes · 13 min read
Understanding High Availability: Lessons from the Bilibili Outage
DevOps
DevOps
Jul 12, 2021 · Operations

The First Four Chaos Experiments to Run on Apache Kafka

This article explains how to use chaos engineering with Gremlin to design, execute, and analyze four experiments that test Kafka broker load, message loss, split‑brain scenarios, and ZooKeeper outages, helping improve the reliability and resilience of Kafka deployments.

Distributed SystemsGremlinKafka
0 likes · 18 min read
The First Four Chaos Experiments to Run on Apache Kafka
IT Architects Alliance
IT Architects Alliance
Jul 11, 2021 · Backend Development

10 Best Practices for Designing a Robust Microservices Architecture

This article explains how adopting ten essential microservice best practices—such as single responsibility, independent data stores, asynchronous communication, circuit breakers, API gateways, backward‑compatible APIs, versioning, dedicated infrastructure, independent release pipelines, and organizational efficiency—helps build a loosely‑coupled, scalable, and maintainable backend system.

BackendBest PracticesDistributed Systems
0 likes · 9 min read
10 Best Practices for Designing a Robust Microservices Architecture
Tech Musings
Tech Musings
Jul 11, 2021 · Fundamentals

Why Distributed Consistency Algorithms Matter and How Raft Achieves Consensus

This article explains why distributed systems need consistency algorithms, compares weak and strong consistency, outlines the challenges of unreliable networks and clocks, and provides a detailed walkthrough of the Raft consensus protocol, its node states, state variables, RPCs, and a practical lab implementation for leader election.

Consensus AlgorithmDistributed SystemsRaft
0 likes · 12 min read
Why Distributed Consistency Algorithms Matter and How Raft Achieves Consensus
DeWu Technology
DeWu Technology
Jul 9, 2021 · Cloud Computing

Common Service Registration Centers: Principles and Comparisons

The article compares four popular service registration centers—Eureka, Zookeeper, Consul, and Nacos—by outlining each system’s architecture, core principles, and operational mechanisms, with an in‑depth source‑code‑level examination of Nacos’s pull/push discovery, Raft‑based leader election, and concurrent instance management, and concludes with a comparative table of consistency, availability, and partition‑tolerance characteristics.

ConsulDistributed SystemsNacos
0 likes · 20 min read
Common Service Registration Centers: Principles and Comparisons
Python Programming Learning Circle
Python Programming Learning Circle
Jul 9, 2021 · Databases

Key Features of ClickHouse: DBMS Capabilities, Columnar Storage, Vectorized Execution, and Distributed Architecture

ClickHouse is an MPP column‑oriented DBMS that combines full DBMS functionality, advanced columnar storage with high compression, SIMD‑based vectorized execution, a rich relational SQL interface, diverse table engines, multi‑master clustering, and flexible sharding and distributed query capabilities, making it exceptionally fast for analytical workloads.

ClickHouseColumnar StorageDBMS
0 likes · 21 min read
Key Features of ClickHouse: DBMS Capabilities, Columnar Storage, Vectorized Execution, and Distributed Architecture
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 9, 2021 · Backend Development

How to Build Your Own Distributed RPC Framework from Scratch

This article walks through the motivation, core components, technology choices, architecture, and implementation details—including service registration, provider and consumer modules, custom protocol design, serialization, load balancing, and Netty-based I/O—of a self‑written distributed RPC framework, and presents performance test results.

Distributed SystemsNettyRPC
0 likes · 17 min read
How to Build Your Own Distributed RPC Framework from Scratch
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 8, 2021 · Backend Development

Mastering Microservice Architecture: 10 Essential Design Patterns Explained

This comprehensive guide explores microservice architecture—from its historical roots and core characteristics to ten vital design patterns such as database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—detailing their advantages, drawbacks, and practical usage scenarios.

Backend ArchitectureCQRSDesign Patterns
0 likes · 28 min read
Mastering Microservice Architecture: 10 Essential Design Patterns Explained
Tech Musings
Tech Musings
Jul 8, 2021 · Big Data

Building a Simple Single-Node MapReduce System: From Theory to Code

This article walks through implementing a lightweight single‑machine MapReduce framework inspired by the original MapReduce paper, covering the abstract Map/Reduce model, task scheduling between master and workers, core Go code for map, reduce, worker, and coordinator, and a brief reflection on its limitations.

Big DataDistributed SystemsLab
0 likes · 10 min read
Building a Simple Single-Node MapReduce System: From Theory to Code
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 8, 2021 · Backend Development

Roadmap to Becoming a Java Backend Architect: Skills from Junior to Senior

From a fresh Java junior engineer to a seasoned architect, this guide outlines the essential skills, technologies, and responsibilities at each career stage—1‑3 years, 3‑5 years, and 5‑8 years—highlighting data structures, algorithms, frameworks, distributed systems, and database expertise needed for backend development.

Backend DevelopmentDistributed SystemsSkills
0 likes · 5 min read
Roadmap to Becoming a Java Backend Architect: Skills from Junior to Senior
FunTester
FunTester
Jul 7, 2021 · Backend Development

Distributed Control System FunTester: Updates, Local Deployment, Swagger Support, Async Execution, and Multi‑Request Features

The article introduces the DCS_FunTester framework, explains its naming, provides Swagger API access, details local deployment steps, describes a header‑based authentication change, outlines asynchronous test execution, multi‑request handling, progress tracking, and includes relevant Java code snippets for building and running the system.

Async ExecutionBackendDistributed Systems
0 likes · 10 min read
Distributed Control System FunTester: Updates, Local Deployment, Swagger Support, Async Execution, and Multi‑Request Features
High Availability Architecture
High Availability Architecture
Jul 5, 2021 · Cloud Native

Edge Cloud Native Platform Development and Architecture – Insights from Zhou Jing

Zhou Jing shares his journey from backend architecture to leading Alibaba Cloud's edge cloud native container platform, discussing recent projects, technical challenges, design principles, emerging trends like ServiceMesh and WebAssembly, and his role in the GIAC 5G edge computing conference.

Distributed Systemscontainer platformedge computing
0 likes · 16 min read
Edge Cloud Native Platform Development and Architecture – Insights from Zhou Jing
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 3, 2021 · Backend Development

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

The article explains how to abstract remote data location logic using an RPC framework built on Spring and Dubbo, demonstrates proxy injection and service registration, and shows how similar principles are applied to Redis Cluster to reduce request redirection and improve scalability.

Backend DevelopmentDistributed SystemsRedis
0 likes · 12 min read
Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster
macrozheng
macrozheng
Jul 2, 2021 · Backend Development

From Zero to Running RocketMQ: My First Producer‑Consumer Walkthrough

This article chronicles my step‑by‑step journey of learning Apache RocketMQ, from downloading the source and building it with Maven, configuring mirrors, launching NameServer, Broker, Producer and Consumer on Windows, to exploring the system’s architecture and design principles.

BackendDistributed SystemsMaven
0 likes · 17 min read
From Zero to Running RocketMQ: My First Producer‑Consumer Walkthrough
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 1, 2021 · Backend Development

Designing a Scalable User Center: Architecture, Redis Caching, and Common Pitfalls

This article outlines the architecture of a high‑traffic user center system, detailing core requirements, distributed session and transaction handling, caching strategies with Redis and local caches, common challenges such as hot data and high‑frequency queries, and provides practical solutions and a concise summary.

BackendDistributed SystemsSystem architecture
0 likes · 4 min read
Designing a Scalable User Center: Architecture, Redis Caching, and Common Pitfalls
Top Architect
Top Architect
Jun 29, 2021 · Backend Development

Microservices Architecture: Principles, Benefits, Drawbacks, and Practical Implementation Guide

This comprehensive article explains the microservices architectural style, contrasts it with monolithic (integrated) architecture, outlines the problems solved by microservices, details design principles, splitting strategies, patterns such as Strangler and Rehab, and provides a complete Java SpringBoot example with code snippets and deployment instructions.

DevOpsDistributed Systemsservice decomposition
0 likes · 23 min read
Microservices Architecture: Principles, Benefits, Drawbacks, and Practical Implementation Guide
Architecture Digest
Architecture Digest
Jun 29, 2021 · Backend Development

Microservice Architecture Design Patterns

This article introduces key microservice architecture design patterns—including Database per Service, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—explaining their advantages, drawbacks, appropriate usage scenarios, and example technologies to guide scalable, resilient system design.

Backend ArchitectureDesign PatternsDistributed Systems
0 likes · 27 min read
Microservice Architecture Design Patterns