கற்றல் ஆப்-க்கு offline sync வடிவமைக்கவும்: conflict-களை எப்படித் தீர்ப்பீர்கள்?

Question

IT Interview Practice · Accepted Answer

ஆப்-ஐ **offline-first** ஆகக் கருதுங்கள்: ஒவ்வொரு சாதனமும் ஒரு உள்ளூர் **replica**. படிப்பு செயல்கள் ஒரு **local DB** உடன் ஒரு append-only **op log** (outbox)-லும் எழுதப்படுகின்றன; மீண்டும் இணைக்கும்போது சாதனம் **தன் ops-ஐ push செய்து** கடைசி sync-க்குப் பிறகான **server changes-ஐ pull செய்கிறது**. Conflict-கள் ஒரு global விதி மூலம் **அல்ல**, மாறாக **ஒவ்வொரு data field-இன் semantics** மூலம் தீர்க்கப்படுகின்றன.

**சிந்தனை மாதிரி:** இதை **git** போலக் கருதுங்கள் — ஒவ்வொரு சாதனமும் offline-ஆக இருக்கும்போது உள்ளூர் ஆக "commit" செய்கிறது, மேலும் sync என்பது ஒரு **merge**, overwrite அல்ல.

## கட்டமைப்பு

```text
Device (offline)                        Server = source of truth
┌──────────────────┐   on reconnect     ┌───────────────────────────┐
│ Local DB (SQLite)│  push ops (delta)  │ Sync API  /sync           │
│ + Op log (outbox)│ ─────────────────▶ │  • idempotent by op.id    │
│ cursor = lastSeen│ ◀───────────────── │  • merge by semantics     │
└──────────────────┘  pull changes>cursor└───────────────────────────┘
                                         Progress DB (Postgres)
```

- **Local DB + op log:** ஒவ்வொரு மாற்றமும் ஒரு **client-generated id கொண்ட immutable op** + version; offline-ஆக இருக்கும்போது queue செய்யப்படுகிறது. UI உள்ளூர்-ஆகப் படித்து/எழுதுவதால் network இல்லாமலும் அது smooth-ஆக இருக்கும்.
- **Sync service:** **cursor-based delta** sync — client cursor-க்குப் பிறகான ops-ஐ push செய்து, அதை விட புதிய changes-ஐ pull செய்கிறது. ஒவ்வொரு sync-ம் முழு dataset-ஐ அல்ல, **delta-ஐ மட்டுமே** நகர்த்துகிறது → 5M பயனர்களும் மலிவாக இருக்கிறது.
- **Conflict resolver:** per-field அர்த்தத்தின்படி merge செய்கிறது (கீழே). **Server-ஏ source of truth**; smoothness-க்காக client முதலில் தீர்க்கிறது, பிறகு server **அதே** deterministic merge-ஐ மீண்டும் apply செய்கிறது.

## Conflict resolution (இதுவே அடிப்படை)

Phone clocks **நம்பகமற்றவை**, மேலும் இரண்டு சாதனங்கள் ஒரே record-ஐ offline-ஆக edit செய்யலாம், எனவே **"last write wins" (LWW) அமைதியாக data-ஐ இழக்கிறது**. Semantics மூலம் தீர்க்கவும்:

- **Monotonic fields** (lesson progress) → **max**-ஐ எடுத்துக்கொள்ளுங்கள்.
- **Additive counters** (மொத்த study time) → **delta-ஐக் கூட்டுங்கள்** (CRDT-style grow-only counter).
- **உண்மையான "latest state"** (scroll position) → LWW ஏற்கத்தக்கது.

```js
// op-க்கு ஒரு id உண்டு -> idempotent-ஆக apply செய் (retries இரட்டையாக எண்ணாது). clientTs நம்பப்படுவதில்லை.
function mergeProgress(server, op) {
  return {
    // progress எப்போதும் அதிகரிக்கும் -> max: தாமதமான பழைய op ஒருபோதும் பின்னோக்கி இழுக்காது
    progress: Math.max(server.progress ?? 0, op.progress),
    // studiedMs ஒரு additive counter -> delta-ஐக் கூட்டு, overwrite செய்யாதே
    studiedMs: (server.studiedMs ?? 0) + op.studiedMs,
    completedAt: server.completedAt ?? (op.progress >= 1 ? op.clientTs : null),
  };
}
```

இங்கே, plain LWW-ஆல் தாமதமாக sync செய்யும் ஒரு பழைய சாதனம் `progress: 0.3` உடன் server-இன் `0.9`-ஐ **overwrite** செய்யவிடும் → progress இழப்பு. `max` எடுத்து `studiedMs`-ஐக் கூட்டுவது sync-ஐ **order-independent** ஆக்குகிறது — skewed clocks கொண்ட மில்லியன் கணக்கான சாதனங்கள் sync செய்யும்போது பாதுகாப்பானது.

## நேர்காணல் பார்வை

**Client clocks-ஐ நம்ப முடியாது** என்பதை நீங்கள் அறிவீர்களா (எனவே pure timestamp LWW அல்ல), sync-ஐ **idempotent** ஆக்குகிறீர்களா (op ids), மேலும் **data அர்த்தத்தின்படி merge** செய்கிறீர்களா என்பதை நேர்காணல் செய்பவர் ஆராய்கிறார். ஒரு **பலவீனமான** பதில்: "timestamps பயன்படுத்து, last write wins." ஒரு **வலுவான** பதில்: replica + op log + idempotency + per-field merge + server-ஏ source of truth — மேலும் LWW-இன் **data-loss** தோல்வியை வெளிப்படையாகப் பெயரிடுவது.

## Trade-offs

LWW மலிவானது ஆனால் lossy; semantic merge-க்கு per-field சிந்தனை தேவை ஆனால் **எதையும் இழக்காது**. உண்மையான collaborative editing (notes, documents) தேவைப்படும்போது மட்டுமே முழு **CRDT/OT**-ஐ நோக்கிச் செல்லுங்கள் — அது செலவு அதிகம், எனவே அனைத்திற்கும் அதைப் பயன்படுத்தாதீர்கள்.

கட்டமைப்பு

Conflict resolution (இதுவே அடிப்படை)

நேர்காணல் பார்வை

Trade-offs

தொடர்புடைய கேள்விகள்