# pacelc

Published articles for pacelc.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Consistency Models in Azure Cosmos DB: From Strong to Eventual

DevFeed: [Consistency Models in Azure Cosmos DB: From Strong to Eventual](<https://devfeed.tech/articles/consistency-models-in-azure-cosmos-db-from-strong-to-eventual-39561.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/09-cosmosdb-consistency-models/>)

Author: hello@ankit-rana.com

Published: 2026-03-16T00:00:00Z

Content type: article

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [consistency](<https://devfeed.tech/topics/consistency.md>), [Database](<https://devfeed.tech/topics/database.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Azure](<https://devfeed.tech/topics/azure.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [cloud-architecture](<https://devfeed.tech/tags/cloud-architecture.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cosmosdb](<https://devfeed.tech/tags/cosmosdb.md>), [database-design](<https://devfeed.tech/tags/database-design.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [latency](<https://devfeed.tech/tags/latency.md>), [linearizable](<https://devfeed.tech/tags/linearizable.md>), [pacelc](<https://devfeed.tech/tags/pacelc.md>), [replication](<https://devfeed.tech/tags/replication.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

This article explains how Azure Cosmos DB uses five consistency levels to expose PACELC trade-offs between consistency, availability, latency, and read freshness. It describes Strong consistency, bounded staleness, and Session consistency, including their operational trade-offs and suitable use cases.

### Source excerpt

Cosmos DB exposes the PACELC trade-off as five explicit levels instead of forcing a strong-or-eventual choice. Strong gives linearizable reads at the cost of write latency and availability. Session, the practical default for user-facing apps, gives read-your-writes within a session via per-partition session tokens while staying highly available.

## Availability and availability

DevFeed: [Availability and availability](<https://devfeed.tech/articles/availability-and-availability-12482.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2018/02/25/availability-liveness.html>)

Author: Marc Brooker

Published: 2018-02-25T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [CAP theorem](<https://devfeed.tech/topics/cap-theorem.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [c](<https://devfeed.tech/tags/c.md>), [cap-theorem](<https://devfeed.tech/tags/cap-theorem.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [graceful-degradation](<https://devfeed.tech/tags/graceful-degradation.md>), [pacelc](<https://devfeed.tech/tags/pacelc.md>), [paper](<https://devfeed.tech/tags/paper.md>), [people](<https://devfeed.tech/tags/people.md>), [system](<https://devfeed.tech/tags/system.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

CAP Availability means every request to a non-failing node gets a response; operational availability usually means the share of client requests seen as successful. The excerpt argues these measures do not map directly: an Available design can let clients on either side of a partition make progress, while a Consistent design may stop clients separated from the majority. But practical availability also depends on workload shape, failure detection and failover delays, and whether clients can reach the nodes they depend on. Available designs may help in limited circumstances, not guarantee high client availability. Harvest and Yield suggests graceful degradation through partial or stale responses, but its usefulness depends on client promises: people may tolerate these answers more readily than computers expecting complete, authoritative responses, though neither rule is absolute.

### Source excerpt

Availability and availability Translating math into engineering. It's well known that the term Availability in the CAP theorem (as formally defined by Gilbert and Lynch) means something different from the term availability that's commonly used by the designers, builders and operators of distributed systems. Gilbert and Lynch define availability for the CAP theorem as: every request received by a non-failing node in the system must result in a response. That's cool, and useful for the mathematical analysis that's needed to prove the CAP theorem. Most builders and users of distributed systems, on the other hand, define availability as the percentage of requests that their clients see as successful, or something close to that. The terms, like 'clients' and 'successful' and 'see', are pretty fuzzy. Not much good for analysis, but more useful for capturing what people care about. This isn't a new observation. You can find a whole lot of writing about it online. Some of that writing is pretty great. What I don't see addressed as often is how to translate one into the other, using the CAP (or PACELC or whatever) reasoning about Availability to help us think about availability. In reality, are Available systems more available than Consistent systems? This post isn't a complete answer to that question, but does include some of the things worth thinking about in that space. Harvest and Yield Before I dive into this topic, it's worth talking about Harvest and Yield, from a paper by Fox and Brewer. The paper itself has some flaws (as I've blogged about before), but the underlying concept is very useful. The core is about graceful degradation, and how it's useful for systems to return partial or stale answers when they aren't able to answer authoritatively. The paper makes its case well, but whether its conclusions are practically useful depend on what promises you make to your clients. If the direct clients of your service are people, then you're likely to be able to get away w

## Harvest and Yield: Not A Natural Cure for Tradeoff Confusion

DevFeed: [Harvest and Yield: Not A Natural Cure for Tradeoff Confusion](<https://devfeed.tech/articles/harvest-and-yield-not-a-natural-cure-for-tradeoff-confusion-12464.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2014/10/12/harvest-yield.html>)

Author: Marc Brooker

Published: 2014-10-12T00:00:00Z

Content type: opinion

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [CAP theorem](<https://devfeed.tech/topics/cap-theorem.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Database](<https://devfeed.tech/topics/database.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [availability](<https://devfeed.tech/tags/availability.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [bloom-filters](<https://devfeed.tech/tags/bloom-filters.md>), [cap-theorem](<https://devfeed.tech/tags/cap-theorem.md>), [completeness](<https://devfeed.tech/tags/completeness.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [linearizability](<https://devfeed.tech/tags/linearizability.md>), [pacelc](<https://devfeed.tech/tags/pacelc.md>), [partition](<https://devfeed.tech/tags/partition.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

The harvest-and-yield model describes a practical tradeoff during faults: a system can preserve the chance of responding (yield) while returning a less complete answer (harvest). The author values this idea, along with graceful degradation and provisioning state management separately for subsystems that need strong consistency or persistence. They criticize the paper for unclear definitions, conflating partial responses with bandwidth and latency techniques, and presenting CA in a way that may suggest it is viable even with linearizability or serializability. The author concludes that harvest and yield help describe design choices within the limits CAP identifies; they are not a replacement for CAP. This overview reflects the supplied excerpt.

### Source excerpt

Harvest and Yield: Not A Natural Cure for Tradeoff Confusion Comments on a 15 year old paper. As I wrote about in my post on PACELC, I don't think the CAP theorem is the right way for teachers to present distributed systems tradeoffs. I also don't think it's ideal for working practitioners, despite its wide use. I prefer Abadi's PACELC, but there are legitimate criticisms of that one too. One criticism is that it's poorly formalized, which makes it hard to apply to precise statements. Another is the PC/EL is an awkward edge case. There are more. Fox and Brewer's harvest and yield model, from Harvest, Yield, and Scalable Tolerant Systems, is a widely promoted alternative. While I like the concepts of harvest and yield, I find it hard to recommend the paper. Both Eric Brewer and Armando Fox have made big contributions to the field, and I like many of their papers. I just don't like this one. I'll start with what I dislike most about it. From the first page: Partition-resilience means that the system as whole can survive a partition between data replicas. CA without P: Databases that provide distributed transactional semantics can only do so in the absence of a network partition separating server peers. I find these statements awkward, and feel like they support the mistaken belief that CA is a valid option. You certainly can't pick CA where your C is linearizability (as in Gilbert and Lynch's proof) or serializability. If you're allowed to pick CA, either your definition of C is weaker than either of those, your definition of A doesn't require minority partitions to make progress, or you're in denial about network partitions (which do exist). Compare the definition of CP: CP without A: In the event of a partition, further transactions to an ACID database may be blocked until the partition heals, to avoid the risk of introducing merge conflicts (and thus inconsistency). Is that saying that CA exists, but just introduces inconsistencies that CP doesn't? Overall, I don't

## CAP and PACELC: Thinking More Clearly About Consistency

DevFeed: [CAP and PACELC: Thinking More Clearly About Consistency](<https://devfeed.tech/articles/cap-and-pacelc-thinking-more-clearly-about-consistency-12460.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2014/07/16/pacelc.html>)

Author: Marc Brooker

Published: 2014-07-16T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [CAP theorem](<https://devfeed.tech/topics/cap-theorem.md>), [consistency](<https://devfeed.tech/topics/consistency.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [ca](<https://devfeed.tech/tags/ca.md>), [cap-theorem](<https://devfeed.tech/tags/cap-theorem.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [learning](<https://devfeed.tech/tags/learning.md>), [pacelc](<https://devfeed.tech/tags/pacelc.md>), [partition](<https://devfeed.tech/tags/partition.md>), [partitions](<https://devfeed.tech/tags/partitions.md>), [teaching](<https://devfeed.tech/tags/teaching.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>)

### AI overview

The article argues that CAP is a misleading teaching shorthand: partition tolerance cannot simply be discarded, and CAP does not forbid every client or replica from making progress with consistency and availability during a partition. PACELC adds the normal-operation tradeoff between latency and consistency: with a partition, systems trade availability against consistency; otherwise, they trade latency against consistency. This highlights practical costs CAP omits and distinguishes strongly consistent PC/EC systems from PA/EL systems that reduce coordination. But PACELC retains ambiguities: it does not clarify when a network problem counts as a partition, and PC/EL can misleadingly suggest consistency improves during a partition. The author finds PACELC more useful for beginners than CAP, but not an ideal replacement.

### Source excerpt

CAP and PACELC: Thinking More Clearly About Consistency CAP is confusing. PACELC is better, but still not ideal. In some sense, the CAP theorem has been too successful. With its snappy name and apparently easy-to-understand behavior, CAP has become the go-to way of talking about tradeoffs in distributed systems. Despite its apparent simplicity, confusion, misunderstandings, misrepresentations and debates about CAP are widespread. Criticism of CAP is also widespread, both in its use as a teaching tool and as a way of reasoning about tradeoffs. Dan Weinreb, Henry Robinson, and Michael Stonebraker have written good examples of the genre. It would be great to find a tool for teaching, and learning about, these tradeoffs that doesn't have the same shortcomings as CAP. In this post, my focus is on CAP as a tool for learning and teaching about distributed systems tradeoffs, rather than its use by experienced practitioners. The problems with CAP as a teaching tool, as I see them, are: The popular belief is that CAP means pick any two. The confusion is about the existence of CA systems, which pretend that partition tolerance is optional, or claim that partitions don't happen. Marketing from database vendors plays into this, too. In reality, you can't sacrifice partition tolerance, because partitions happen in real large-scale systems all the time. There is some evidence that the popularity of this misconception is waning, but it would be premature to announce its death. The second misconception is that the CAP theorem means you can't be consistent and available during partitions. That's not true, at least in the case of Gilbert and Lynch's version of the theorem. Specifically, the CAP theorem only prevents everybody from being consistent and available, not anybody (some literature calls this always available). It doesn't prevent clients and replicas on the majority side of simple partitions from making progress, and experiencing both consistency and availability. There are o