BestHub
Sign in
Tagged articles

consistency

345 articles · Page 1 of 4
Architect
Architect
Sep 13, 2026 · Artificial Intelligence

Multi-Agent Consistency: Distributed Systems Challenges Return with Autonomous Agents

The article explores four critical questions for multi-agent consistency: task decomposition rationale, structured handoffs with versioned snapshots, conflict resolution via evidence-based contracts, and verifiable completion criteria. It argues multi-agent systems reintroduce classic distributed systems challenges—identity, leases, idempotency, compensation—and require runtime proofs over model assertions.

Agent ArchitectureRuntime Verificationagent orchestration
0 likes · 21 min read
Multi-Agent Consistency: Distributed Systems Challenges Return with Autonomous Agents
Data Bricklaying Diary
Data Bricklaying Diary
Sep 11, 2026 · Backend Development

Distributed Systems' Hardest Challenge: State Over Interfaces — Consistency, Idempotency & Async Tasks

This article explores why cross-service state management is harder than API design in distributed systems, using a refund example to illustrate how local transactions, idempotency, state machines, Outbox patterns, and manual intervention achieve recoverable convergence when operations span multiple services and external channels.

Outbox Patternasync tasksconsistency
0 likes · 21 min read
Distributed Systems' Hardest Challenge: State Over Interfaces — Consistency, Idempotency & Async Tasks
ITPUB
ITPUB
Sep 1, 2026 · Industry Insights

The Untold History of China's Database Industry: 50 Years of Struggle, Innovation, and Consistency

A sweeping narrative chronicles four decades of China's database development, detailing how engineers fought foreign lock‑downs, built home‑grown systems, pioneered theoretical frameworks, and reshaped data sovereignty through real‑world events like TPC‑C records, 301 investigations, and the "去IOE" movement.

ChinaIndustry HistoryTPC-C
0 likes · 26 min read
The Untold History of China's Database Industry: 50 Years of Struggle, Innovation, and Consistency
ITPUB
ITPUB
Aug 25, 2026 · Databases

From Modeling to Systematic Theory: Tracing a Decade of Database Consistency Evolution (2020‑2025)

The article reviews a speaker’s ten‑year journey from building multi‑level consistency models and defining over twenty new data anomalies to exposing ANSI‑SQL’s isolation flaws, unveiling the “Eight Immortals” consistency diagram, proposing the CCDB architecture with zero‑time unlock, and finally codifying three concurrent‑system design principles.

CCDBConcurrencyconsistency
0 likes · 30 min read
From Modeling to Systematic Theory: Tracing a Decade of Database Consistency Evolution (2020‑2025)
Data Integration and Governance
Data Integration and Governance
Aug 21, 2026 · Fundamentals

How to Manage Data Quality? A Complete Breakdown of the Six Dimensions

Enterprises often start data governance with standards, yet the real challenge is answering “Is this data accurate?” – a challenge solved by a continuous mechanism that discovers, locates, resolves, and verifies issues across six dimensions (completeness, consistency, accuracy, uniqueness, timeliness, validity) and follows a five‑step governance loop.

Data Qualityaccuracycompleteness
0 likes · 16 min read
How to Manage Data Quality? A Complete Breakdown of the Six Dimensions
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Aug 12, 2026 · Databases

ZestKV Achieves 2.3× SET Write Throughput, Surpassing pika3.5 at 700k QPS

By parallelizing both the write side and the response side—using multi‑queue write concurrency, overlapping network and CPU work, batch wake‑ups, and connection‑based sharding—ZestKV raises SET request throughput from 310 k to 700 k QPS, more than double pika 3.5, while preserving full consistency and durability guarantees.

ParallelismPerformance OptimizationZestKV
0 likes · 12 min read
ZestKV Achieves 2.3× SET Write Throughput, Surpassing pika3.5 at 700k QPS
YiSu Grain
YiSu Grain
Aug 10, 2026 · Databases

Choosing the Right NoSQL Model: From Four Data Types to CAP Trade‑offs

This article explains the four major NoSQL data models—key‑value, document, column‑family, and graph—detailing their structures, strengths, weaknesses, CAP trade‑offs, consistency options, and how to match each model to specific business queries and requirements, including polyglot persistence strategies.

CAPData ModelingNoSQL
0 likes · 29 min read
Choosing the Right NoSQL Model: From Four Data Types to CAP Trade‑offs
YiSu Grain
YiSu Grain
Aug 8, 2026 · Databases

Day 51: Database Architecture – Master‑Slave Replication, Read‑Write Separation, Sharding & Consistency

The article walks through diagnosing database bottlenecks, explains MySQL replication flow, read‑write separation benefits and limits, shows when to apply vertical versus horizontal partitioning, details sharding‑key selection, cross‑shard challenges, high‑availability steps, and presents a complete e‑commerce case study.

Database ReplicationHorizontal PartitioningRead-Write Separation
0 likes · 29 min read
Day 51: Database Architecture – Master‑Slave Replication, Read‑Write Separation, Sharding & Consistency
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 5, 2026 · Backend Development

Spring Boot + Caffeine: Multi-Level Cache Architecture, Consistency & Load Tests

This article details integrating Caffeine with Spring Boot 3.x for a three-tier L1/L2/DB cache architecture, covering Window TinyLFU internals, refreshAfterWrite vs expireAfterWrite, manual vs annotation-driven integration, read/write paths, message-driven invalidation with version stamps, load test results showing 48k QPS at 2ms P99, and production tuning for memory, GC, and hot-key protection.

CaffeineJavaLoad Testing
0 likes · 20 min read
Spring Boot + Caffeine: Multi-Level Cache Architecture, Consistency & Load Tests
samdeepthink
samdeepthink
Aug 3, 2026 · Backend Development

Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?

The article examines why the common update‑database, delete‑cache, add‑TTL workflow can still produce permanent stale data under high concurrency, explains the underlying race conditions, and compares several alternative strategies—including delete‑first, binlog‑driven invalidation, and lease‑based approaches—to help engineers choose the most reliable and low‑complexity solution for cache consistency.

BinlogMySQLRedis
0 likes · 19 min read
Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?
LuTiao Programming
LuTiao Programming
Jul 25, 2026 · Backend Development

Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency

The article analyzes why MySQL and Redis cannot guarantee strong consistency with simple cache‑aside patterns, explains the pitfalls of delayed double delete, and presents a tiered Java design—including transaction‑after‑commit deletion, retryable invalidation, CDC/Outbox pipelines, TTL safeguards, and multi‑level cache considerations—to achieve reliable cache consistency.

CDCCache invalidationJava
0 likes · 22 min read
Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency
samdeepthink
samdeepthink
Jul 22, 2026 · Backend Development

Why You Should Minimize Local Cache Usage

The article argues that local caches add significant consistency and management complexity, so they should be avoided unless a genuine performance bottleneck exists, illustrating the point with real‑world promotion spikes, GC concerns, and careful off‑heap testing.

GCRedisSystem Design
0 likes · 4 min read
Why You Should Minimize Local Cache Usage
IT Learning Made Simple
IT Learning Made Simple
Jul 21, 2026 · Fundamentals

Key Takeaways from 'Designing Large-Scale Distributed Systems'

This note distills the core engineering practices for building and operating large‑scale distributed systems, covering system definition, distributed vs single‑node trade‑offs, CAP theorem choices, consistency levels, transaction patterns, load‑balancing algorithms, cache strategies, message‑queue reliability, coordination services like ZooKeeper, and essential design principles.

CAP theoremZooKeepercaching
0 likes · 11 min read
Key Takeaways from 'Designing Large-Scale Distributed Systems'
Random Bulletin
Random Bulletin
Jul 17, 2026 · Backend Development

Ten‑Million QPS Architecture: From Strong to Eventual Consistency with Layered Design

The article examines why ultra‑high‑throughput systems must move from costly strong consistency to eventual consistency, explaining consistency layering, the trade‑offs of coordination latency, availability, and tail latency, and how local message tables, idempotent delivery, compensation (Saga) and periodic reconciliation together ensure data eventually aligns without sacrificing performance.

SAGAcompensationconsistency
0 likes · 17 min read
Ten‑Million QPS Architecture: From Strong to Eventual Consistency with Layered Design
Cloud Architecture
Cloud Architecture
Jul 16, 2026 · Backend Development

Beyond Delayed Double Delete: How CDC Closed‑Loop Governance Solves Cache Consistency

The article dissects why the classic "update‑DB‑then‑delete‑cache" or its reverse is only a probability fix for cache inconsistency, demonstrates the failure modes of delayed double delete under high load and replication lag, and presents a production‑grade solution built on Binlog CDC with versioning, four‑plane governance, and robust error handling to achieve reliable cache synchronization.

BackendCDCcache
0 likes · 36 min read
Beyond Delayed Double Delete: How CDC Closed‑Loop Governance Solves Cache Consistency
YiSu Grain
YiSu Grain
Jul 6, 2026 · Backend Development

Why a Single Order Triggers a Distributed Transaction (2PC, TCC, Saga Explained)

The article explains why a single order operation can involve multiple services and databases, introduces the challenges of distributed transactions, and compares three common solutions—Two‑Phase Commit, TCC, and Saga—detailing their mechanisms, strengths, weaknesses, and suitable scenarios.

2PCMicroservicesSAGA
0 likes · 12 min read
Why a Single Order Triggers a Distributed Transaction (2PC, TCC, Saga Explained)
YiSu Grain
YiSu Grain
Jul 6, 2026 · Fundamentals

Understanding CAP and BASE Through a Simple Network Partition Example

The article explains the CAP theorem and BASE model by walking through a concrete scenario of two data centers losing network connectivity, showing how architects must choose between consistency and availability and illustrating typical CP and AP use cases.

BASECAP theoremavailability
0 likes · 9 min read
Understanding CAP and BASE Through a Simple Network Partition Example
Tinker Programmer
Tinker Programmer
Jul 3, 2026 · Backend Development

How Aggregate Roots Guard Business Invariants – The Final Defense Line

The article examines a payroll bug caused by exposing internal collections, then explains three immutable‑focused rules for aggregate roots—expose only through the root, keep each transaction to a single aggregate, and reference other aggregates by ID only—showing how proper design prevents consistency errors, performance loss, and concurrency conflicts in Spring Boot applications.

@TransactionalAggregate RootDomain Events
0 likes · 17 min read
How Aggregate Roots Guard Business Invariants – The Final Defense Line
AI Programming Lab
AI Programming Lab
Jul 3, 2026 · Databases

Why OceanBase’s AI Database Is More Than Just a Vector Store

The article analyzes how OceanBase’s new AI‑native database tackles the data‑layer challenges of autonomous agents by introducing logical tables, multi‑modal storage, Fork DB sandboxes and lake‑warehouse integration, arguing that the product’s value lies beyond simple vector retrieval.

AI DatabaseAgentFork DB
0 likes · 12 min read
Why OceanBase’s AI Database Is More Than Just a Vector Store
Cloud Architecture
Cloud Architecture
Jun 30, 2026 · Backend Development

RocketMQ Transactional Messaging in Practice: From Half Message to Production‑Grade Consistency

The article analyses why sending a message is easy but guaranteeing end‑to‑end consistency across databases, brokers, networks and services is hard, explains the exact problems RocketMQ transactional messages solve, compares them with Outbox and CDC, and provides a complete production‑grade design, implementation, monitoring and tuning guide.

CDCOutboxRocketMQ
0 likes · 44 min read
RocketMQ Transactional Messaging in Practice: From Half Message to Production‑Grade Consistency
Niu Liu
Niu Liu
Jun 25, 2026 · Backend Development

Don’t Mix Them Up: When to Use RPC, MQ, or Offline Scripts

The article breaks down three fundamental mechanisms—synchronous RPC, asynchronous MQ, and offline scripts—by comparing their lifecycles, IO models, bottlenecks, and consistency guarantees, and provides a concrete decision framework for choosing the right tool for different business scenarios.

Batch ProcessingMicroservicesRPC
0 likes · 12 min read
Don’t Mix Them Up: When to Use RPC, MQ, or Offline Scripts
Niu Liu
Niu Liu
Jun 24, 2026 · Databases

Splitting an Order Database into Hot and Cold Stores: Our Practical Approach

The article details how an e‑commerce platform re‑architected its order database by separating recent data into a hot store and historical data into a cold store, describing the motivations, design principles, write and read routing, downstream impacts, consistency safeguards, risks, and observed performance improvements.

Binlogbackend scalabilityconsistency
0 likes · 8 min read
Splitting an Order Database into Hot and Cold Stores: Our Practical Approach
AI Engineer Programming
AI Engineer Programming
Jun 21, 2026 · Artificial Intelligence

RAG Data Governance: Incremental Sync and Consistency (Part 1)

The article explains how additions, updates, and deletions affect a vector store differently, outlines three layers of incremental synchronization—change detection, change handling, and service stability—and compares timestamp polling, content‑hash diffing, and CDC while discussing consistency models and conflict resolution in distributed vector databases.

CDCRAGconsistency
0 likes · 16 min read
RAG Data Governance: Incremental Sync and Consistency (Part 1)
ZhiKe AI
ZhiKe AI
Jun 14, 2026 · Fundamentals

Why Consistency Is a Luxury: A Practical Guide to BASE Theory in Distributed Systems

During peak events like Alibaba's Double‑11 and WeChat's red‑packet frenzy, distributed systems must trade strict consistency for availability; this article explains the CAP theorem, introduces the BASE model, compares CP and AP designs, and provides real‑world case studies and selection guidelines.

ACIDBASE theoryCAP theorem
0 likes · 15 min read
Why Consistency Is a Luxury: A Practical Guide to BASE Theory in Distributed Systems
ZhiKe AI
ZhiKe AI
Jun 13, 2026 · Fundamentals

Why Banks Let You Wait but Never Miscalculate: A 5‑Minute Guide to the CAP Theorem

Every delay you notice in WeChat messages, flash‑sale pages, or bank transfers stems from the same underlying distributed‑system trade‑off, and this article explains the CAP theorem, its three guarantees, common misconceptions, and how CP versus AP architectures shape real‑world services.

BASE modelCAP theoremCP vs AP
0 likes · 11 min read
Why Banks Let You Wait but Never Miscalculate: A 5‑Minute Guide to the CAP Theorem
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
May 29, 2026 · Artificial Intelligence

WBench: 20 Cutting‑Edge World Models Face a Comprehensive Interactive Benchmark

WBench, a new benchmark created by Meituan LongCat and Fudan University, evaluates 20 state‑of‑the‑art video and world‑model systems across 289 test cases and 1,058 interaction rounds, measuring video quality, setting adherence, interaction fidelity, consistency and physical compliance, and reveals that no model yet excels in all five dimensions.

Interactive BenchmarkMultimodal EvaluationWBench
0 likes · 10 min read
WBench: 20 Cutting‑Edge World Models Face a Comprehensive Interactive Benchmark
MeowKitty Programming
MeowKitty Programming
May 6, 2026 · Backend Development

Why Faster AI Code Generation Demands Strong Transaction Boundaries for Java Developers

As AI accelerates Java business code generation, developers must carefully define transaction boundaries, distinguishing atomic operations, avoiding oversized or overly fragmented transactions, and coordinating with messaging and caching to ensure consistency, recoverability, and reliable system behavior.

AI code generationJavaMicroservices
0 likes · 8 min read
Why Faster AI Code Generation Demands Strong Transaction Boundaries for Java Developers
IT Services Circle
IT Services Circle
Apr 23, 2026 · Backend Development

Why You Can Skip Consistency Checks When Using DB and MinIO Together

The article argues that for typical file‑upload scenarios you should upload to MinIO first and then write to the database without trying to enforce strong distributed consistency, explaining the pitfalls of transaction‑based solutions and offering simple async cleanup strategies.

@TransactionalAsync CleanupBackend
0 likes · 8 min read
Why You Can Skip Consistency Checks When Using DB and MinIO Together
Cloud Architecture
Cloud Architecture
Mar 11, 2026 · Databases

Why Data Sync Failures Aren’t the DBA’s Fault – A Deep Dive into Synchronization Strategies

Data synchronization problems often cause user complaints, inventory mismatches, and search gaps, but the root cause lies in application‑level design; this article explains the fundamentals, challenges, common scenarios, and evaluates five synchronization patterns—including cache‑aside, read‑through, write‑behind, binlog‑based replication, and transactional messaging—plus monitoring, reconciliation, and best‑practice guidelines.

BinlogTransactional Messagingcache-aside
0 likes · 28 min read
Why Data Sync Failures Aren’t the DBA’s Fault – A Deep Dive into Synchronization Strategies
IT Services Circle
IT Services Circle
Mar 7, 2026 · Backend Development

Beyond Simple Redis: Advanced Multi‑Level Cache Strategies for High‑Performance Backend Systems

This article explores a series of unconventional yet practical caching designs—including consistent hashing with local caches, request‑scope caching, session‑level caching, client‑side caching, pre‑loading, and graceful degradation—to dramatically improve backend response times, reliability, and interview impact.

backend architectureconsistencyperformance
0 likes · 18 min read
Beyond Simple Redis: Advanced Multi‑Level Cache Strategies for High‑Performance Backend Systems
Su San Talks Tech
Su San Talks Tech
Jan 20, 2026 · Databases

How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios

This article examines the common data‑consistency problems that arise when updating both a database and a cache under high concurrency, evaluates four typical write‑order strategies, and presents the most reliable solution—writing to the database first and then safely invalidating the cache using retry, scheduled tasks, MQ, or binlog listeners.

Cache invalidationHigh ConcurrencyMQ
0 likes · 17 min read
How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios
JD Cloud Developers
JD Cloud Developers
Dec 8, 2025 · Fundamentals

Why Raft Guarantees Linear Consistency in Unreliable Networks

This article explains how unreliable networks, clock instability, and node failures can cause data inconsistency in distributed clusters, introduces the Raft consensus algorithm, details its roles, election process, log replication, read/write handling, consistency models, and mechanisms to avoid split-brain and livelock.

ConsensusLog ReplicationRaft
0 likes · 13 min read
Why Raft Guarantees Linear Consistency in Unreliable Networks
Architect's Journey
Architect's Journey
Nov 29, 2025 · Backend Development

Cache Design Guidelines: Achieve Microsecond Queries and Survive Traffic Spikes

This article outlines practical cache design principles, covering suitable scenarios, health metrics, common pitfalls like avalanche, breakdown and penetration, and concrete implementation rules for both local (Caffeine) and Redis caches to ensure microsecond‑level response and stable high‑traffic performance.

Rediscache avalanchecache penetration
0 likes · 13 min read
Cache Design Guidelines: Achieve Microsecond Queries and Survive Traffic Spikes
360 Smart Cloud
360 Smart Cloud
Nov 25, 2025 · Cloud Native

How PoleFS Achieves Microsecond I/O with Multi‑Layer Caching and CTO Consistency

PoleFS is a high‑performance, cloud‑native distributed file system that combines NVMe‑accelerated hot storage with S3‑based cold storage, offering multiple client access methods, multi‑level metadata and data caches, prefetch/warm‑up strategies, and a Close‑to‑Open consistency model to balance performance and data correctness.

Storagecachingcloud-native
0 likes · 11 min read
How PoleFS Achieves Microsecond I/O with Multi‑Layer Caching and CTO Consistency
Bilibili Tech
Bilibili Tech
Nov 21, 2025 · Backend Development

How Bilibili Scaled Its Private Messaging System to Handle 10× Traffic

This article analyzes the current bottlenecks of Bilibili's private messaging service, explains the technical challenges of massive data volume and traffic spikes, and presents a comprehensive multi‑layer architecture upgrade—including cache strategies, BFF refactoring, database sharding, and consistency mechanisms—to ensure scalability and reliability.

BFFMicroservicesconsistency
0 likes · 16 min read
How Bilibili Scaled Its Private Messaging System to Handle 10× Traffic
FunTester
FunTester
Nov 18, 2025 · Artificial Intelligence

Why Unambiguous, Consistent Requirements Are Critical for AI Code Generation

In the age of AI‑driven code generation, requirements must be both unambiguous and consistent to avoid misinterpretation, unpredictable outputs, and faulty logic, ensuring that generated code aligns with stakeholder intent and maintains quality.

AI code generationambiguityconsistency
0 likes · 7 min read
Why Unambiguous, Consistent Requirements Are Critical for AI Code Generation
Ray's Galactic Tech
Ray's Galactic Tech
Nov 14, 2025 · Databases

Mastering MySQL Master‑Slave Read/Write Splitting: 4 Strategies and Real‑World Practices

This article explains MySQL master‑slave replication, why read/write splitting is essential, four practical read‑distribution strategies, the main causes of replication lag, four solutions for write‑after‑read consistency, multi‑slave allocation methods, replication modes, and a real‑world e‑commerce decision matrix, ending with a golden architecture recommendation.

MySQLRead-Write SplittingReplication
0 likes · 11 min read
Mastering MySQL Master‑Slave Read/Write Splitting: 4 Strategies and Real‑World Practices
Ray's Galactic Tech
Ray's Galactic Tech
Oct 29, 2025 · Databases

Master‑Slave Consistency in MySQL: 4 Proven Strategies to Eliminate Replication Lag

This article explains why MySQL master‑slave replication can fall behind, outlines common causes of data inconsistency, and presents four comprehensive solutions—including architecture tweaks, multi‑threaded replication, configuration tuning, and Percona Toolkit verification—to achieve fast, stable, and accurate data synchronization.

LagMySQLReplication
0 likes · 9 min read
Master‑Slave Consistency in MySQL: 4 Proven Strategies to Eliminate Replication Lag
Alimama Tech
Alimama Tech
Oct 15, 2025 · Artificial Intelligence

How Alibaba’s Taobao Starry Model Delivers Precise, Consistent E‑commerce Image Edits

Alibaba’s Taobao Starry Image Editing model tackles the e‑commerce challenge of maintaining visual consistency by introducing a high‑fidelity, plug‑in architecture, a million‑scale consistency dataset, and multi‑stage multilingual training, enabling precise, controllable edits without altering product layout or background.

Plug‑in Architectureconsistencydata engineering
0 likes · 10 min read
How Alibaba’s Taobao Starry Model Delivers Precise, Consistent E‑commerce Image Edits
Java Baker
Java Baker
Sep 15, 2025 · Backend Development

Choosing the Right Cache Update Pattern: Cache‑Aside, Write‑Back, Read‑Through

This article systematically compares four cache update patterns—cache‑aside, asynchronous write‑back, read/write‑through, and ongoing optimizations—detailing their implementation steps, suitable scenarios, advantages, drawbacks, and practical tips such as delayed double deletion and proactive cache refreshing to balance performance and consistency.

OptimizationWrite-Backcache-aside
0 likes · 9 min read
Choosing the Right Cache Update Pattern: Cache‑Aside, Write‑Back, Read‑Through
Architect's Guide
Architect's Guide
Aug 25, 2025 · Fundamentals

19 Essential Distributed System Design Patterns You Must Know

This article explores nineteen core design patterns for distributed systems—including Bloom filters, consistent hashing, quorum, leader‑follower, heartbeat, fencing, WAL, segmented logs, high‑water mark, leases, gossip, Phi accrual detection, split‑brain handling, checksums, CAP and PACELC theorems, hinted handoff, read repair, and Merkle trees—explaining their purpose, operation, and typical use cases.

consistencydistributed systemsfault tolerance
0 likes · 14 min read
19 Essential Distributed System Design Patterns You Must Know
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Aug 10, 2025 · Databases

How Single-Leader Replication Handles Write Conflicts: Strategies and Insights

This article examines write conflicts in single-leader replication, comparing exclusive and shared data, exploring uniqueness constraints, async replication delays, and various conflict‑resolution techniques such as unique indexes, bitmap mapping, LWW ordering, and multi‑version control for collaborative editing.

Replicationconsistencydatabase
0 likes · 9 min read
How Single-Leader Replication Handles Write Conflicts: Strategies and Insights
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Aug 3, 2025 · Fundamentals

Understanding Causal Consistency: Order Guarantees, Lamport Timestamps, and Total Order Broadcast

This article explains the challenges of implementing causal consistency, compares it with linear and sequential consistency, describes how order guarantees are enforced in leader‑based replication, introduces Lamport timestamps and total‑order broadcast, and outlines practical approaches for achieving causal consistency in distributed systems.

Lamport timestampReplicationcausal consistency
0 likes · 14 min read
Understanding Causal Consistency: Order Guarantees, Lamport Timestamps, and Total Order Broadcast
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Jul 6, 2025 · Databases

Demystifying Consistency Models: From Linear to Eventual in Distributed Systems

This article explores the concept of consistency in distributed systems, breaking down various consistency models—including linear, sequential, causal, and eventual—explaining their definitions, practical implications, and how they guide the design of high‑availability architectures and data replication strategies.

consistencyconsistency modelsdata replication
0 likes · 13 min read
Demystifying Consistency Models: From Linear to Eventual in Distributed Systems
Subtle Storm
Subtle Storm
Jun 10, 2025 · Cloud Native

Master Distributed Architecture in One Comprehensive Guide

This article explains the concept, design goals, evolution, core components, real‑world scenarios, and key challenges of distributed architecture, illustrating how load balancing, sharding, consensus algorithms and modern cloud‑native tools enable scalable, highly available systems.

Distributed ArchitectureKubernetesMicroservices
0 likes · 9 min read
Master Distributed Architecture in One Comprehensive Guide
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Jun 8, 2025 · Databases

Why Data Replication Matters: Architectures, Formats, and Consistency Models

This article explores the principles of data replication, comparing shared memory, shared disk, and non‑shared storage architectures, detailing replication formats, consistency challenges, and various replication strategies such as synchronous, asynchronous, semi‑synchronous, and majority‑based approaches, helping engineers choose the right trade‑offs.

asynchronous replicationconsistencydata replication
0 likes · 12 min read
Why Data Replication Matters: Architectures, Formats, and Consistency Models
Cognitive Technology Team
Cognitive Technology Team
May 14, 2025 · Backend Development

Cache and Database Consistency: Strategies for Updating Order

This article examines common cache‑database consistency challenges and compares four update strategies—including write‑through, cache‑aside, and delayed double‑delete—to help backend developers choose the most suitable approach for maintaining data integrity in high‑traffic systems.

cachecache-asideconsistency
0 likes · 6 min read
Cache and Database Consistency: Strategies for Updating Order
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 25, 2025 · Databases

Essential Knowledge Points of Redis Cluster

Redis cluster relies on two ports per node, a hash‑slot based sharding scheme, a master‑slave replication model, and provides eventual consistency, making these four fundamentals essential knowledge for developers and operators to.

Master‑SlaveRediscluster
0 likes · 6 min read
Essential Knowledge Points of Redis Cluster
Cognitive Technology Team
Cognitive Technology Team
Apr 3, 2025 · Fundamentals

Understanding CAP Theory and BASE: Data Consistency in Distributed Systems

This article explains the CAP theorem and its practical extension BASE, describing their core concepts, trade‑off combinations, typical components such as Zookeeper, Eureka, and Nacos, and engineering techniques like asynchronous replication, Saga, and idempotent design for building highly available distributed systems.

BASECAP theoremavailability
0 likes · 5 min read
Understanding CAP Theory and BASE: Data Consistency in Distributed Systems
IT Architects Alliance
IT Architects Alliance
Jan 13, 2025 · Fundamentals

Strong Consistency vs. Eventual Consistency in Distributed Systems

The article explains the principles, implementation techniques, trade‑offs, and typical use cases of strong consistency and eventual consistency in distributed systems, helping architects decide which model best fits the performance, availability, and correctness requirements of their applications.

CAP theoremconsistencyeventual consistency
0 likes · 13 min read
Strong Consistency vs. Eventual Consistency in Distributed Systems
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 7, 2025 · Backend Development

Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis

This article examines why many large‑scale systems avoid the traditional delayed double‑delete cache‑invalidation strategy, explains its critical drawbacks, and presents alternative lease‑based and version‑based approaches with Lua scripts and Java wrappers for Redis to achieve stronger consistency.

Delayed Double DeleteJavaLua
0 likes · 17 min read
Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis
IT Architects Alliance
IT Architects Alliance
Jan 6, 2025 · Fundamentals

Mastering the CAP Theorem: Balancing Consistency, Availability, and Partition Tolerance

An in‑depth guide explains the CAP theorem’s three pillars—Consistency, Availability, Partition Tolerance—illustrates why only two can be achieved simultaneously, and shows real‑world trade‑offs across e‑commerce, finance, and social platforms, while introducing the complementary BASE model for practical system design.

BASE modelCAP theoremSystem Design
0 likes · 15 min read
Mastering the CAP Theorem: Balancing Consistency, Availability, and Partition Tolerance
IT Architects Alliance
IT Architects Alliance
Dec 27, 2024 · Fundamentals

Understanding Distributed Architecture: Concepts, Evolution, Core Technologies, Applications, Challenges, and Future Outlook

This article explains what distributed architecture is, traces its historical development, details core technologies such as consensus protocols and load balancing, explores real‑world applications in e‑commerce, fintech and big data, discusses key challenges and mitigation strategies, and looks ahead to its role in AI, IoT and blockchain.

Cloud Computingconsistency
0 likes · 22 min read
Understanding Distributed Architecture: Concepts, Evolution, Core Technologies, Applications, Challenges, and Future Outlook
JavaEdge
JavaEdge
Dec 23, 2024 · Backend Development

How Meta Achieves Near‑Perfect Cache Consistency: Lessons from Polaris

This article explains why cache consistency is critical for Meta, how the company measures and monitors consistency, the design of the Polaris system that detects and resolves stale cache entries, and provides a concrete Python‑style example illustrating the challenges and solutions.

MetaPolarisconsistency
0 likes · 14 min read
How Meta Achieves Near‑Perfect Cache Consistency: Lessons from Polaris
Tencent Cloud Developer
Tencent Cloud Developer
Nov 27, 2024 · Databases

Analyzing the Write‑After‑Read Consistency Challenge in Multi‑Active Distributed Architectures

The article examines the write‑after‑read consistency problem in multi‑active cross‑region systems, compares single‑write‑single‑read routing, quorum‑based multi‑write‑multi‑read, and read‑while‑copy methods, explains why primary‑secondary replication is preferred, and proposes a four‑step framework—scenario flagging, data marking, latency evaluation, and near‑by asynchronous replication—to meet WAR requirements efficiently.

Database ReplicationMulti-Activeconsistency
0 likes · 12 min read
Analyzing the Write‑After‑Read Consistency Challenge in Multi‑Active Distributed Architectures
JD Retail Technology
JD Retail Technology
Nov 5, 2024 · Backend Development

Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions

The article examines how frequent inventory adjustments in JD retail supply‑chain can suffer from concurrency issues, explains why traditional locking may fail, analyzes a real‑world case of lock misuse, and presents code‑level, database‑level, and architectural solutions to guarantee data consistency.

ConcurrencyInventoryconsistency
0 likes · 7 min read
Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions
Architecture and Beyond
Architecture and Beyond
Oct 19, 2024 · R&D Management

How Consistent Architecture Prevents System Decay: Style, Solution, and Form

The article explains why architectural consistency—across style, implementation solutions, and formal design—is essential for preventing decay in evolving enterprise systems, and provides concrete practices such as unified patterns, standardized tech stacks, documentation, code reviews, and toolchain standardization to maintain flexibility and maintainability.

R&D managementconsistencydesign principles
0 likes · 18 min read
How Consistent Architecture Prevents System Decay: Style, Solution, and Form
Lobster Programming
Lobster Programming
Aug 9, 2024 · Backend Development

Why Zookeeper Is Losing Favor: Consistency vs. Availability Trade‑offs

Zookeeper, the open‑source coordination service modeled after Google’s Chubby, offers strong consistency for distributed applications, but its CP design, synchronous master‑slave replication, log‑heavy state changes, and limited health checks lead many large tech firms to favor more available alternatives, though it still fits certain use cases.

consistencycpdistributed systems
0 likes · 5 min read
Why Zookeeper Is Losing Favor: Consistency vs. Availability Trade‑offs
dbaplus Community
dbaplus Community
Jul 4, 2024 · Databases

How Uber Scaled Docstore with CacheFront: An Integrated Caching Solution

This article details Uber's Docstore distributed database challenges and explains the design, architecture, and implementation of CacheFront—a transparent, high‑performance caching layer that reduces latency, improves scalability, and maintains strong consistency across microservices.

Rediscachingconsistency
0 likes · 19 min read
How Uber Scaled Docstore with CacheFront: An Integrated Caching Solution
Volcano Engine Developer Services
Volcano Engine Developer Services
Jul 3, 2024 · Backend Development

How We Scaled a Billion‑Item Search Engine with Elasticsearch: From Zero to One

This article details the practical journey of building and scaling an Elasticsearch‑based search system that supports tens of millions to billions of items, covering architecture design, capacity planning, multi‑data‑center deployment, data synchronization via RocketMQ and Flink, and multi‑layer reconciliation to ensure consistency and high QPS.

ElasticsearchFlinkRocketMQ
0 likes · 15 min read
How We Scaled a Billion‑Item Search Engine with Elasticsearch: From Zero to One
DaTaobao Tech
DaTaobao Tech
Jun 17, 2024 · Backend Development

Cache Consistency Issues and Solutions in a High‑Concurrency Push System

The article examines a cache‑consistency failure in Tmall International’s high‑concurrency push system, explains classic cache problems and mitigation techniques, analyzes the delete‑then‑update bug that caused null‑plan errors, and evaluates four corrective strategies ranging from double‑write to delayed double‑delete.

BackendData ConsistencyHigh Concurrency
0 likes · 13 min read
Cache Consistency Issues and Solutions in a High‑Concurrency Push System
Architect
Architect
May 6, 2024 · Backend Development

Designing Effective Multi‑Level Cache Architecture for Microservices

This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.

BackendCDNMicroservices
0 likes · 16 min read
Designing Effective Multi‑Level Cache Architecture for Microservices
ITPUB
ITPUB
Apr 22, 2024 · Backend Development

How Meta Achieves Near‑Perfect Cache Consistency: Lessons from Polaris

This article explains Meta's approach to cache invalidation and consistency, detailing why ultra‑high consistency matters, how their Polaris monitoring system detects and resolves inconsistencies, and provides a simplified Python example that illustrates the underlying mechanisms and challenges.

BackendMetaPolaris
0 likes · 12 min read
How Meta Achieves Near‑Perfect Cache Consistency: Lessons from Polaris
dbaplus Community
dbaplus Community
Apr 14, 2024 · Backend Development

How Meta Reached 99.99999999% Cache Consistency and What You Can Learn

This article explains Meta's approach to cache invalidation and consistency, why ultra‑high consistency matters for user experience, the monitoring infrastructure they built, the Polaris system that detects and repairs inconsistencies, and provides a concrete Python‑style code example illustrating the problem and solution.

BackendMetaPolaris
0 likes · 13 min read
How Meta Reached 99.99999999% Cache Consistency and What You Can Learn
Ops Development & AI Practice
Ops Development & AI Practice
Mar 14, 2024 · Artificial Intelligence

Do Vector Embeddings Offer the Same Consistency as Hash Functions?

While both vectorization and hashing are essential for handling large datasets, this article examines whether vector embeddings can match the deterministic consistency of hash functions, comparing their collision handling, data structure design implications, and suitability for retrieval and machine‑learning tasks.

AIInformation Retrievalcollision handling
0 likes · 8 min read
Do Vector Embeddings Offer the Same Consistency as Hash Functions?
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 16, 2024 · Databases

MySQL Master‑Slave Synchronization: Three Common Approaches and Consistency Solutions

This article explains why read‑write separation is essential for high‑concurrency systems and details three MySQL master‑slave synchronization methods—half‑synchronous replication, database‑middleware synchronization, and cache‑key write tracking—along with their advantages, drawbacks, and consistency considerations.

Master‑SlaveMySQLcache
0 likes · 6 min read
MySQL Master‑Slave Synchronization: Three Common Approaches and Consistency Solutions
Tencent Cloud Developer
Tencent Cloud Developer
Jan 19, 2024 · Backend Development

Should You Use Exceptions in Modern C++? A Deep Dive into Consistency, Coroutines, and Real‑World Trade‑offs

This article revisits a 2017 decision to ban exceptions in a large codebase, examines the technical and organizational reasons behind that rule, analyzes exception mechanics, coroutine interactions, and performance impacts with concrete C++ examples, and finally proposes a pragmatic action plan for safely adopting exception‑driven design.

Best PracticesC++consistency
0 likes · 33 min read
Should You Use Exceptions in Modern C++? A Deep Dive into Consistency, Coroutines, and Real‑World Trade‑offs
Su San Talks Tech
Su San Talks Tech
Jan 15, 2024 · Backend Development

Mastering Distributed Transactions: 8 Powerful Techniques Explained

This article introduces eight essential distributed‑transaction techniques—including 2PC, 3PC, TCC, Saga, distributed locks, local message tables, reliable message transactions, and best‑effort notifications—detailing their workflows, advantages, drawbacks, and suitable business scenarios to help engineers choose the right solution.

2PC3PCSAGA
0 likes · 16 min read
Mastering Distributed Transactions: 8 Powerful Techniques Explained
JavaEdge
JavaEdge
Jan 13, 2024 · Backend Development

Ensuring Consistency, Idempotency, and Reliable Retries in Payment Systems

The article explains how payment systems should link related documents to maintain status and amount consistency, implement idempotency through unique keys, and use progressive retry mechanisms with message queues to handle network glitches and ensure reliable transaction processing.

Retryconsistencyidempotency
0 likes · 5 min read
Ensuring Consistency, Idempotency, and Reliable Retries in Payment Systems
Su San Talks Tech
Su San Talks Tech
Jan 3, 2024 · Backend Development

How Nacos Implements Service Registration: From Ephemeral Instances to CP/AP Consistency

This article deep‑dives into Nacos as a service registry, explaining the differences between temporary and permanent instances, registration mechanisms across 1.x and 2.x versions, heartbeat and health‑check strategies, service discovery methods, data‑consistency models, and the underlying data model that powers Nacos clusters.

NacosconsistencygRPC
0 likes · 28 min read
How Nacos Implements Service Registration: From Ephemeral Instances to CP/AP Consistency
MaGe Linux Operations
MaGe Linux Operations
Dec 3, 2023 · Backend Development

How to Ensure Cache‑Database Consistency: Strategies and Best Practices

This article explains why introducing a cache improves read performance as traffic grows, compares different cache‑database consistency approaches, analyzes their pros and cons in concurrent scenarios, and recommends using the "update database then delete cache" pattern with message queues or change‑log subscriptions to maintain data integrity.

Backendcachingconsistency
0 likes · 12 min read
How to Ensure Cache‑Database Consistency: Strategies and Best Practices
Architects' Tech Alliance
Architects' Tech Alliance
Oct 3, 2023 · Fundamentals

Survey on In‑Network Storage Systems

This survey systematically reviews the research progress of in‑network storage systems, covering programmable network hardware characteristics, the two main challenges of building high‑performance solutions, task‑based classification of existing systems, representative designs, and future research directions such as switch‑NIC collaboration, multi‑tenant support, security, and automatic offloading.

In‑Network StorageNetwork AccelerationProgrammable Switches
0 likes · 12 min read
Survey on In‑Network Storage Systems
Tencent Cloud Developer
Tencent Cloud Developer
Sep 13, 2023 · Cloud Native

Designing and Implementing a Payment Fund Account System

The article details how to design and implement a cloud‑native payment fund account system on Tencent Cloud, covering account definitions, fund flow and multiple account types, TDSQL storage, separated fund and account services, robust security, distributed transactions, auditing, reconciliation, and high‑availability measures for high‑concurrency merchant payments.

SecurityTDSQLTransaction Processing
0 likes · 35 min read
Designing and Implementing a Payment Fund Account System
Java High-Performance Architecture
Java High-Performance Architecture
Jul 24, 2023 · Backend Development

Business Compensation in Distributed Systems: Rollback, Retry, and Consistency

This article explains how distributed systems handle business inconsistencies through compensation mechanisms, detailing rollback versus retry approaches, their implementation patterns such as explicit/implicit rollback, various retry strategies, and the trade‑offs between ACID and BASE consistency models for achieving eventual consistency.

MicroservicesRetrybusiness compensation
0 likes · 11 min read
Business Compensation in Distributed Systems: Rollback, Retry, and Consistency
Bilibili Tech
Bilibili Tech
May 19, 2023 · Backend Development

Local Cache Optimization for Outbox Redis in a High‑Traffic Feed Stream Service

To protect the outbox Redis cluster from extreme read amplification during hot events, the service adds a resident local cache for hot creators’ latest posts, using a threshold‑based list, change‑broadcast updates, and checksum verification, which achieved over 55% cache hits and cut peak Redis load by roughly 44% and CPU usage by 37%.

Performance ScalingRediscache optimization
0 likes · 10 min read
Local Cache Optimization for Outbox Redis in a High‑Traffic Feed Stream Service
FunTester
FunTester
May 4, 2023 · Fundamentals

How to Build Trust in Test Results with Authoritative Test Criteria

The article explains why testers need clear system boundaries and authoritative test criteria, outlines methods to identify system components, and presents seven consistency dimensions—user requirements, comparable products, historical behavior, visual design, statements, standards, and purpose—to ensure reliable and repeatable testing outcomes.

consistencyfundamentalsquality assurance
0 likes · 6 min read
How to Build Trust in Test Results with Authoritative Test Criteria
政采云技术
政采云技术
Apr 27, 2023 · Backend Development

Understanding CAP Theorem, BASE Theory, and Their Implementation with Zookeeper (CP) and Eureka (AP)

This article explains the CAP theorem and its trade‑offs, introduces the BASE model as a practical compromise, and demonstrates how Zookeeper implements a CP registration center while Eureka adopts an AP approach, illustrating the impact on consistency, availability, and partition tolerance in distributed systems.

BASE theoryCAP theoremEureka
0 likes · 12 min read
Understanding CAP Theorem, BASE Theory, and Their Implementation with Zookeeper (CP) and Eureka (AP)
政采云技术
政采云技术
Apr 25, 2023 · Backend Development

Cache System Overview, Architecture Evolution, Pain Points, and Best Practices

This article explains the fundamentals of cache systems, describes the evolution from no‑cache to distributed and local caches, analyzes common challenges such as consistency, hot‑key detection, and cache avalanche, and provides practical guidelines and real‑world lessons for designing effective backend caching solutions.

Backend Performancearchitecturecaching
0 likes · 14 min read
Cache System Overview, Architecture Evolution, Pain Points, and Best Practices
Architects Research Society
Architects Research Society
Apr 21, 2023 · Databases

Understanding Sequential, Causal, and Eventual Consistency Models

This article explains the concepts of sequential, causal, and eventual consistency in distributed systems, illustrating their guarantees with examples and diagrams, and discusses related consistency guarantees such as monotonic reads, writes, and read‑your‑writes, helping readers grasp how these models affect system behavior and performance.

causal consistencyconsistencyeventual consistency
0 likes · 13 min read
Understanding Sequential, Causal, and Eventual Consistency Models
Top Architect
Top Architect
Mar 28, 2023 · Backend Development

Ensuring Data Consistency Between Cache and Database: Strategies and Trade‑offs

This article examines various strategies for maintaining data consistency between caches (such as Redis and local memory) and databases during double-write operations, evaluates their advantages and drawbacks, and proposes solutions like delayed double deletion, message‑queue compensation, and binlog‑based cache updates.

consistencydatabase
0 likes · 8 min read
Ensuring Data Consistency Between Cache and Database: Strategies and Trade‑offs
Architects Research Society
Architects Research Society
Mar 1, 2023 · Fundamentals

Understanding Consistency in Distributed Systems

This article explains the concept of consistency in distributed systems, distinguishes strong and weak (eventual) consistency, outlines typical use cases and challenges, and reviews key protocols such as 2‑Phase Commit, 3‑Phase Commit, Paxos, and Raft, while referencing the FLP and CAP theorems.

2PC3PCCAP theorem
0 likes · 9 min read
Understanding Consistency in Distributed Systems