mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
475 lines
24 KiB
HTML
475 lines
24 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>distributed-systems-cap-theorem</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/distributed-systems-cap-theorem.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/distributed-systems-cap-theorem">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/distributed-systems-cap-theorem.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>distributed-systems-cap-theorem</h1><p class="lede">CAP theorem fundamentals, consistency vs availability trade-offs, and practical implications for distributed system design</p><h1>CAP Theorem</h1>
|
|
<p><strong>Scope</strong>: CAP theorem, consistency-availability trade-offs, partition tolerance, system design implications <strong>Lines</strong>: ~290 <strong>Last Updated</strong>: 2025-10-27 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<hr>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Designing distributed systems</li><li>Choosing databases (SQL vs NoSQL)</li><li>Understanding system trade-offs</li><li>Planning for network partitions</li><li>Evaluating consistency models</li><li>Selecting replication strategies</li><li>Making architecture decisions</li><li>Troubleshooting distributed system issues</li></ul>
|
|
<h2>Core Concepts</h2>
|
|
<h3>The CAP Theorem</h3>
|
|
<p><strong>Statement</strong>: In a distributed system, you can only guarantee <strong>two</strong> of three properties:</p>
|
|
<pre><code>C = Consistency
|
|
All nodes see the same data at the same time
|
|
|
|
A = Availability
|
|
Every request receives a response (success or failure)
|
|
|
|
P = Partition Tolerance
|
|
System continues despite network partitions</code></pre>
|
|
<p><strong>Reality</strong>: Network partitions <strong>will</strong> happen, so you must choose between:</p>
|
|
<ul><li><strong>CP</strong>: Consistency + Partition Tolerance (sacrifice availability)</li><li><strong>AP</strong>: Availability + Partition Tolerance (sacrifice consistency)</li></ul>
|
|
<h3>Why CAP?</h3>
|
|
<p><strong>Proof sketch</strong>:</p>
|
|
<pre><code>Given:
|
|
- Network partition splits nodes into two groups
|
|
- Client writes to one side
|
|
- Client reads from other side
|
|
|
|
If Consistent (C):
|
|
→ Must wait for partition to heal
|
|
→ System unavailable (violates A)
|
|
|
|
If Available (A):
|
|
→ Return potentially stale data
|
|
→ Not consistent (violates C)
|
|
|
|
Cannot have both C and A during partition (P)</code></pre>
|
|
<hr>
|
|
<h2>Consistency vs Availability</h2>
|
|
<h3>CP Systems (Consistency + Partition Tolerance)</h3>
|
|
<p><strong>Behavior during partition</strong>: Reject requests to maintain consistency</p>
|
|
<p><strong>Examples</strong>:</p>
|
|
<ul><li>Etcd (used by Kubernetes)</li><li>Consul</li><li>ZooKeeper</li><li>HBase</li><li>MongoDB (with majority writes)</li><li>Traditional SQL databases</li></ul>
|
|
<p><strong>When to choose</strong>:</p>
|
|
<ul><li>Financial transactions</li><li>Inventory management</li><li>Configuration management</li><li>Leader election</li><li>Distributed locks</li></ul>
|
|
<p><strong>Example</strong>:</p>
|
|
<pre><code class="lang-python"># CP system: Returns error if can't guarantee consistency
|
|
try:
|
|
balance = bank_db.get_balance(account_id)
|
|
if balance >= amount:
|
|
bank_db.withdraw(account_id, amount) # Blocks during partition
|
|
except ConsistencyError:
|
|
return "Service temporarily unavailable" # Better than wrong data</code></pre>
|
|
<h3>AP Systems (Availability + Partition Tolerance)</h3>
|
|
<p><strong>Behavior during partition</strong>: Always respond, may return stale data</p>
|
|
<p><strong>Examples</strong>:</p>
|
|
<ul><li>Cassandra</li><li>DynamoDB</li><li>Riak</li><li>CouchDB</li><li>DNS</li><li>Caching systems</li></ul>
|
|
<p><strong>When to choose</strong>:</p>
|
|
<ul><li>Social media feeds</li><li>Product catalogs</li><li>Analytics data</li><li>Logging systems</li><li>Caching layers</li><li>Content delivery</li></ul>
|
|
<p><strong>Example</strong>:</p>
|
|
<pre><code class="lang-python"># AP system: Always returns data, may be stale
|
|
user_profile = cache.get(user_id) # Returns even if stale
|
|
if user_profile is None:
|
|
user_profile = eventual_consistency_db.get(user_id) # Best effort</code></pre>
|
|
<hr>
|
|
<h2>Real-World Considerations</h2>
|
|
<h3>PACELC Extension</h3>
|
|
<p><strong>CAP is incomplete</strong>: Only describes behavior <strong>during</strong> partitions</p>
|
|
<p><strong>PACELC</strong> adds:</p>
|
|
<pre><code>If Partition (P):
|
|
Choose between Availability (A) and Consistency (C)
|
|
Else (E):
|
|
Choose between Latency (L) and Consistency (C)
|
|
|
|
Full framework:
|
|
- PA/EL: Prioritize availability and low latency (Cassandra)
|
|
- PA/EC: Prioritize availability, then consistency (DynamoDB)
|
|
- PC/EL: Prioritize consistency, then low latency (MongoDB)
|
|
- PC/EC: Prioritize consistency (traditional RDBMS)</code></pre>
|
|
<h3>Consistency Spectrum</h3>
|
|
<p><strong>Not binary</strong>:</p>
|
|
<pre><code>Strong Consistency (CP)
|
|
├─ Linearizability
|
|
├─ Sequential Consistency
|
|
└─ Causal Consistency
|
|
|
|
Eventual Consistency (AP)
|
|
├─ Read Your Writes
|
|
├─ Monotonic Reads
|
|
└─ Eventual</code></pre>
|
|
<hr>
|
|
<h2>System Examples</h2>
|
|
<h3>Example 1: Social Media Feed (AP)</h3>
|
|
<pre><code class="lang-python">class SocialMediaFeed:
|
|
"""AP system: Always available, eventually consistent"""
|
|
|
|
def post_update(self, user_id, content):
|
|
# Write to multiple regions asynchronously
|
|
for region in self.regions:
|
|
region.write_async(user_id, content) # Don't wait
|
|
return {"status": "posted"} # Immediate response
|
|
|
|
def get_feed(self, user_id):
|
|
# Read from nearest region
|
|
region = self.get_nearest_region()
|
|
posts = region.read(user_id) # May be slightly stale
|
|
return posts # Always returns something</code></pre>
|
|
<p><strong>Trade-off</strong>: User might not see their post immediately on different device (eventual consistency), but system is always available.</p>
|
|
<h3>Example 2: Bank Account (CP)</h3>
|
|
<pre><code class="lang-python">class BankAccount:
|
|
"""CP system: Strongly consistent, may be unavailable"""
|
|
|
|
def transfer(self, from_account, to_account, amount):
|
|
# Distributed transaction with 2PC
|
|
transaction = self.begin_transaction()
|
|
try:
|
|
# Both operations must succeed or both fail
|
|
transaction.debit(from_account, amount)
|
|
transaction.credit(to_account, amount)
|
|
transaction.commit() # Blocks until confirmed on all nodes
|
|
return {"status": "success"}
|
|
except PartitionError:
|
|
transaction.rollback()
|
|
raise ServiceUnavailableError("Cannot guarantee consistency")
|
|
|
|
def get_balance(self, account_id):
|
|
# Read from majority quorum
|
|
return self.read_with_quorum(account_id) # Blocks if partition</code></pre>
|
|
<p><strong>Trade-off</strong>: System may become unavailable during network issues, but data is always correct.</p>
|
|
<h3>Example 3: Hybrid Approach</h3>
|
|
<pre><code class="lang-python">class HybridSystem:
|
|
"""Different consistency for different data"""
|
|
|
|
def write_user_profile(self, user_id, profile):
|
|
# AP: Profile updates can be eventually consistent
|
|
self.ap_store.write_async(user_id, profile)
|
|
return {"status": "updated"}
|
|
|
|
def charge_payment(self, user_id, amount):
|
|
# CP: Payments must be strongly consistent
|
|
try:
|
|
result = self.cp_store.transaction(user_id, amount)
|
|
return {"status": "charged"}
|
|
except PartitionError:
|
|
return {"status": "unavailable", "retry": True}</code></pre>
|
|
<hr>
|
|
<h2>Database Classification</h2>
|
|
<h3>CP Databases</h3>
|
|
<pre><code>MongoDB (w=majority):
|
|
- Consistent reads from primary
|
|
- Blocks during partition
|
|
- Use for: Transactions, inventory
|
|
|
|
Etcd/Consul:
|
|
- Raft consensus
|
|
- Strong consistency
|
|
- Use for: Configuration, service discovery
|
|
|
|
HBase:
|
|
- Single master, consistent regions
|
|
- May be unavailable during failures
|
|
- Use for: Time-series, analytics requiring consistency</code></pre>
|
|
<h3>AP Databases</h3>
|
|
<pre><code>Cassandra:
|
|
- Tunable consistency (default AP)
|
|
- Eventually consistent
|
|
- Use for: Time-series, logging, IoT
|
|
|
|
DynamoDB:
|
|
- Eventually consistent reads (default)
|
|
- Strongly consistent reads (optional, higher latency)
|
|
- Use for: User profiles, session data
|
|
|
|
Riak:
|
|
- Eventual consistency
|
|
- High availability
|
|
- Use for: Content storage, caching</code></pre>
|
|
<hr>
|
|
<h2>Tunable Consistency</h2>
|
|
<h3>Cassandra Example</h3>
|
|
<pre><code class="lang-python">from cassandra.cluster import Cluster
|
|
from cassandra.query import SimpleStatement
|
|
from cassandra import ConsistencyLevel
|
|
|
|
cluster = Cluster(['node1', 'node2', 'node3'])
|
|
session = cluster.connect('my_keyspace')
|
|
|
|
# AP: Eventually consistent (fast)
|
|
statement = SimpleStatement(
|
|
"SELECT * FROM users WHERE user_id = %s",
|
|
consistency_level=ConsistencyLevel.ONE # Read from any single node
|
|
)
|
|
|
|
# CP: Strongly consistent (slower)
|
|
statement = SimpleStatement(
|
|
"SELECT * FROM users WHERE user_id = %s",
|
|
consistency_level=ConsistencyLevel.QUORUM # Read from majority
|
|
)
|
|
|
|
# Per-query choice based on use case</code></pre>
|
|
<hr>
|
|
<h2>Decision Framework</h2>
|
|
<h3>Choose CP When:</h3>
|
|
<pre><code>✅ Correctness is critical (financial, inventory)
|
|
✅ Can tolerate downtime
|
|
✅ Data conflicts must be prevented
|
|
✅ Transactions required
|
|
✅ Regulated industry (banking, healthcare)</code></pre>
|
|
<h3>Choose AP When:</h3>
|
|
<pre><code>✅ Availability is critical (user-facing)
|
|
✅ Can tolerate stale reads
|
|
✅ Conflicts can be resolved later
|
|
✅ High write throughput needed
|
|
✅ Global distribution required</code></pre>
|
|
<hr>
|
|
<h2>Common Misconceptions</h2>
|
|
<h3>Misconception 1: "CAP means pick 2 of 3"</h3>
|
|
<p><strong>Wrong</strong>: Network partitions happen, so it's really "CP or AP"</p>
|
|
<p><strong>Correct</strong>: Choose consistency or availability <strong>during</strong> partitions</p>
|
|
<h3>Misconception 2: "NoSQL = AP, SQL = CP"</h3>
|
|
<p><strong>Wrong</strong>: Many NoSQL databases offer tunable consistency</p>
|
|
<p><strong>Examples</strong>:</p>
|
|
<ul><li>Cassandra: Can be CP with QUORUM consistency</li><li>MongoDB: Can be AP with w=1 writes</li><li>PostgreSQL: Can be AP with async replication</li></ul>
|
|
<h3>Misconception 3: "AP means no consistency"</h3>
|
|
<p><strong>Wrong</strong>: AP means eventual consistency, not no consistency</p>
|
|
<p><strong>Clarification</strong>: Updates propagate to all nodes, just not immediately</p>
|
|
<hr>
|
|
<h2>Testing CAP Properties</h2>
|
|
<h3>Partition Simulation</h3>
|
|
<pre><code class="lang-python">import subprocess
|
|
import time
|
|
|
|
def simulate_partition(node_ips):
|
|
"""Block network traffic between nodes"""
|
|
for ip in node_ips:
|
|
subprocess.run([
|
|
'iptables', '-A', 'INPUT', '-s', ip, '-j', 'DROP'
|
|
])
|
|
|
|
def test_ap_system():
|
|
"""Test that system remains available during partition"""
|
|
simulate_partition(['192.168.1.2'])
|
|
|
|
# Should still respond (maybe stale)
|
|
response = api.get('/data')
|
|
assert response.status_code == 200 # Available
|
|
|
|
def test_cp_system():
|
|
"""Test that system maintains consistency during partition"""
|
|
simulate_partition(['192.168.1.2'])
|
|
|
|
# Should refuse to serve potentially inconsistent data
|
|
response = api.get('/data')
|
|
assert response.status_code in [503, 500] # Unavailable but consistent</code></pre>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><code>distributed-systems-eventual-consistency</code> - Consistency models</li><li><code>distributed-systems-replication-strategies</code> - Data replication</li><li><code>distributed-systems-consensus-raft</code> - Consensus algorithms</li><li><code>distributed-systems-conflict-resolution</code> - Handling conflicts</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-27</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/distributed-systems-cap-theorem.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |