Ana Veri Yönetimi

İki ders boyunca veri hep tek yönde aktı: bir sistem yazdı, ötekiler okudu. Kaynağı belliydi, bağın yönü belliydi ve iki kopyanın farklı gerçek taşıması diye bir sorun yoktu. Kurumda bu varsayım çoğu varlık için tutmaz. Üye kaydı üyelik sisteminde de, ödünç servisinde de, belediyedeki kimlik servisinde de durur; üçü de kendi ekranından yazılır ve aynı üyenin adresi üç yerde üç farklı değer taşıyabilir.

Bu ders o durumu kurar ve sayar: kaç sistem yazıyor, kaç alan çakışıyor, bir uzlaştırma turunda kaç değer düzeliyor ve geriye ne kalıyor. Sonra sistemlerden biri kaynak sistem seçilir, aynı olay dizisi yeniden koşturulur ve aynı sayılar yeniden okunur.

TM7 — kurum kurgudur; sistemler, alanları, sahipleri ve yazma olayları node içinde bir veri yapısıdır. Rastgelelik tek bir görünür tohumdan üretilir, üreteç kodun içindedir.

TM8 — çoğaltma mekaniği modellenmez. Gerekçe: kopya tutma, çoğaltma gecikmesi ve sonunda tutarlılık ayrı bir kursta ölçüldü. Burada ölçülen şey verinin nasıl kopyalandığı değil, kimin yazdığı ve iki kopyanın farklı gerçek taşımasıdır; yazma anında görünür kabul edilir.

TM9 — uzlaştırma kuralı “en son yazan kazanır” olarak modellenir. Gerekçe: ölçülen nicelik kuralın kendisi değil, kuralın uygulanabildiği yüzeydir. Dışarıdan yazılamayan bir sistemde hangi kural seçilirse seçilsin düzeltme yazılamaz; kuralı değiştirmek kalan tutarsızlığın yerini değil, yalnız kazananı değiştirir.

Aynı Varlık, Üç Sistem

Üç sistem aynı üyeyi tutar ve üçünün alan kümesi farklıdır. Üyelik sistemi dört alan taşır, ödünç servisi üç, belediyedeki kimlik servisi iki. Üçünün de sahibi ayrıdır ve üçünde de kendi kullanıcıları vardır. Belirleyici fark alan sayısında değil, son kolonda: kimlik servisine dışarıdan yazılamaz. Kurum o sistemi okuyabilir, düzeltme gönderemez.

// kurum.mjs — uye kaydini tutan uc sistem: kurgu kurum modeli ve olay ureteci
export const SISTEM = [
  { ad: "uyelik", sahip: "uyelik birimi", disaridanYazilir: 1,
    alan: ["ad", "adres", "telefon", "eposta"] },
  { ad: "odunc", sahip: "ic gelistirme", disaridanYazilir: 1,
    alan: ["ad", "adres", "telefon"] },
  { ad: "kimlik", sahip: "belediye bilgi islem", disaridanYazilir: 0,
    alan: ["ad", "adres"] },
];
export const ALAN = ["ad", "adres", "telefon", "eposta"];
export const UYE = 120, TUR = 6, TOHUM = 20260411;   // uye sayisi, uye basina yazma, gorunur tohum
const uretec = (t) => () => ((t = (t * 1103515245 + 12345) % 2147483648) / 2147483648);

// her sistemin kendi kullanicisi kendi ekranindan yazar; olaylar tek tohumdan uretilir
export const olaylar = () => {
  const r = uretec(TOHUM), o = [];
  for (let u = 1; u <= UYE; u += 1) {
    for (let t = 1; t <= TUR; t += 1) {
      const s = SISTEM[Math.floor(r() * SISTEM.length)];
      const a = s.alan[Math.floor(r() * s.alan.length)];
      o.push({ uye: u, sistem: s.ad, alan: a, deger: `d${Math.floor(r() * 4)}`, zaman: t });
    }
  }
  return o;
};

if (process.argv[1].endsWith("kurum.mjs")) {
  const O = olaylar();
  console.log(`${SISTEM.length} sistem ayni varligi tutuyor, ` +
    `${new Set(SISTEM.map((s) => s.sahip)).size} ayri sahip; ` +
    `disaridan yazilabilen ${SISTEM.filter((s) => s.disaridanYazilir).length}`);
  for (const s of SISTEM) {
    console.log(`  ${s.ad.padEnd(8)}${String(s.alan.length).padStart(2)} alan  ` +
      `${String(O.filter((o) => o.sistem === s.ad).length).padStart(3)} yazma  ${s.sahip}`);
  }
  console.log(`toplam ${O.length} yazma, ${UYE} uye, ${ALAN.length} alan`);
}

3 sistem ayni varligi tutuyor, 3 ayri sahip; disaridan yazilabilen 2
  uyelik   4 alan  224 yazma  uyelik birimi
  odunc    3 alan  258 yazma  ic gelistirme
  kimlik   2 alan  238 yazma  belediye bilgi islem
toplam 720 yazma, 120 uye, 4 alan

İki Yazma Düzeni

Dağıtık düzende yazma hangi ekrandan geldiyse oraya düşer ve orada kalır. Altın kayıt düzeninde dışarıdan yazılabilen sistemlerin ekranlarından gelen her yazma önce kaynak sisteme gider, oradan öteki yazılabilir sistemlere yayılır; belediyenin kendi ekranından gelen yazma bu düzenin dışında kalır. Uzlaştırma turu her iki düzende de aynı işlevle koşar: çakışan her alan için en son yazılmış değer bulunur ve yazılabilen sistemlere işlenir.

// duzen.mjs — iki yazma duzeni ve uzlastirma turu; depo bicimi: depo[sistem][uye][alan]
import { SISTEM } from "./kurum.mjs";
const bul = (s) => SISTEM.find((x) => x.ad === s);
export const bos = () => Object.fromEntries(SISTEM.map((s) => [s.ad, {}]));
export const koy = (k, s, u, a, d, z) => {       // tasimiyorsa yazma adimi harcanmaz
  if (!bul(s).alan.includes(a)) return 0;
  (k[s][u] ??= {})[a] = { d, z };
  return 1;
};
// dagitik duzen: yazma hangi sistemin ekranindan geldiyse oraya duser
export const dagitik = (k, o, kapali) => (kapali.includes(o.sistem)
  ? { adim: 0, ilk: null }
  : { adim: koy(k, o.sistem, o.uye, o.alan, o.deger, o.zaman), ilk: o.sistem });
// altin kayit duzeni: disaridan yazilabilen her yazma once kaynak sisteme gider, oradan yayilir
export const altin = (k, o, kapali, kaynak = "uyelik") => {
  if (!bul(o.sistem).disaridanYazilir) return dagitik(k, o, kapali);
  if (kapali.includes(kaynak)) return { adim: 0, ilk: null };
  let adim = koy(k, kaynak, o.uye, o.alan, o.deger, o.zaman);
  for (const s of SISTEM.filter((x) => x.disaridanYazilir && x.ad !== kaynak)) {
    adim += koy(k, s.ad, o.uye, o.alan, o.deger, o.zaman);
  }
  return { adim, ilk: kaynak };
};
// cakisma: ayni (uye, alan) icin sistemlerde birden cok farkli deger duruyorsa
export const cakisma = (k, uyeler, alanlar) => uyeler.flatMap((u) => alanlar.flatMap((a) => {
  const v = SISTEM.map((s) => k[s.ad][u]?.[a]).filter(Boolean);
  return new Set(v.map((x) => x.d)).size > 1 ? [{ u, a }] : [];
}));
// uzlastirma turu: en son yazan kazanir, kazanan yazilabilir sistemlere islenir
export const uzlastir = (k, c) => {
  let duzeltilen = 0;
  for (const { u, a } of c) {
    const kazanan = SISTEM.map((s) => ({ ...k[s.ad][u]?.[a] })).filter((x) => x.d)
      .sort((x, y) => y.z - x.z)[0];
    for (const s of SISTEM.filter((x) => x.disaridanYazilir)) {
      const simdi = k[s.ad][u]?.[a];
      if (simdi && simdi.d !== kazanan.d) { koy(k, s.ad, u, a, kazanan.d, kazanan.z); duzeltilen += 1; }
    }
  }
  return duzeltilen;
};

Ölçüm

Araç yedi yüz yirmi yazma olayını önce dağıtık düzende, sonra altın kayıt düzeninde koşturur. Her koşumdan sonra çakışan alan çiftleri sayılır, bir uzlaştırma turu koşar ve tur sonrası çakışma yeniden sayılır. Son ölçü aynı olay dizisini üyelik sistemi kapalıyken yineler ve kaç yazmanın kabul edildiğini sayar.

// olc.mjs — ayni olay dizisini iki duzende kosar ve tutarsizligi sayar
import { ALAN, SISTEM, UYE, olaylar } from "./kurum.mjs";
import { altin, bos, cakisma, dagitik, uzlastir } from "./duzen.mjs";
const O = olaylar(), UYELER = [...Array(UYE).keys()].map((i) => i + 1);
const kos = (yaz, kapali = []) => {
  const k = bos(), ilkler = new Set();
  let adim = 0, kabul = 0;
  for (const o of O) {
    const { adim: n, ilk } = yaz(k, o, kapali);
    adim += n;
    if (ilk) { kabul += 1; ilkler.add(ilk); }
  }
  return { k, adim, kabul, yazan: ilkler.size };
};
const olc = (yaz) => {
  const t = kos(yaz);
  const once = cakisma(t.k, UYELER, ALAN);
  const duzeltilen = uzlastir(t.k, once);
  const sonra = cakisma(t.k, UYELER, ALAN);
  return { ...t, once, duzeltilen, sonra, kapali: kos(yaz, ["uyelik"]).kabul };
};
const D = olc(dagitik), A = olc(altin);
const satir = (ad, x, y) => console.log(`${ad.padEnd(38)}${String(x).padStart(10)}${String(y).padStart(13)}`);

satir("olcu", "dagitik", "altin kayit");
satir("kullanici yazmasini alan sistem", D.yazan, A.yazan);
satir("olay basina yazma adimi", (D.adim / O.length).toFixed(2), (A.adim / O.length).toFixed(2));
satir("cakisan (uye, alan) cifti", D.once.length, A.once.length);
satir("uzlastirma turunda duzeltilen alan", D.duzeltilen, A.duzeltilen);
satir("uzlastirma sonrasi kalan tutarsizlik", D.sonra.length, A.sonra.length);
satir("uyelik kapaliyken kabul edilen yazma", `${D.kapali}/${O.length}`, `${A.kapali}/${O.length}`);
console.log();
console.log(`${"alan".padEnd(9)}${"tasiyan".padStart(8)}${"dagitik cakisan".padStart(17)}` +
  `${"dagitik kalan".padStart(15)}${"altin cakisan".padStart(15)}${"altin kalan".padStart(13)}`);
for (const a of ALAN) {
  const n = (l) => l.filter((x) => x.a === a).length;
  console.log(`${a.padEnd(9)}${String(SISTEM.filter((s) => s.alan.includes(a)).length).padStart(8)}` +
    `${String(n(D.once)).padStart(17)}${String(n(D.sonra)).padStart(15)}` +
    `${String(n(A.once)).padStart(15)}${String(n(A.sonra)).padStart(13)}`);
}

olcu                                     dagitik  altin kayit
kullanici yazmasini alan sistem                3            2
olay basina yazma adimi                     1.00         1.61
cakisan (uye, alan) cifti                    131           95
uzlastirma turunda duzeltilen alan            95           94
uzlastirma sonrasi kalan tutarsizlik          48           48
uyelik kapaliyken kabul edilen yazma     496/720      238/720

alan      tasiyan  dagitik cakisan  dagitik kalan  altin cakisan  altin kalan
ad              3               62             32             53           32
adres           3               54             16             42           16
telefon         2               15              0              0            0
eposta          1                0              0              0            0

Çakışma Nereden Doğuyor

İkinci tablonun ilk kolonu tek başına açıklayıcıdır. Elektronik posta alanı yalnız üyelik sisteminde durur ve hiçbir düzende hiç çakışmaz. Telefon iki sistemde durur, adres ve ad üçünde; çakışma sayıları da bu sıraya uyar. Çakışma alanın önemiyle, doldurulma sıklığıyla ya da veri kalitesiyle değil, o alanı kaç sistemin yazdığıyla doğar. Yüz yirmi üyenin dört alanı için dağıtık düzende yüz otuz bir çakışan çift ölçülüyor; bunların tamamı birden fazla sistemin yazdığı üç alandadır.

Uzlaştırma turu yüz otuz bir çakışmadan doksan beş alan değerini düzeltiyor ve kırk sekiz çakışma geriye kalıyor. Kalanların dağılımı ikinci tablonun dördüncü kolonundadır: otuz ikisi ad, on altısı adres alanında. Bu iki alan, kimlik servisinin taşıdığı iki alandır. Telefon alanındaki on beş çakışmanın tamamı düzeliyor, çünkü telefonu taşıyan iki sistemin ikisi de yazılabilir.

Kalan tutarsızlığın kaynağı uzlaştırma kuralının zayıflığı değildir. En son yazan kazanır kuralı her çakışmada bir kazanan belirler; sorun kazananın öteki sistemlere yazılamamasıdır. Kazanan değer belediyenin sistemindeki değerden farklı çıktığında, kurum o sistemi düzeltemez. Kırk sekiz sayısı bir veri kalitesi ölçüsü değil, bir yetki sınırı ölçüsüdür.

Altın Kayıt Neyi Değiştiriyor

Üyelik sistemi kaynak sistem seçildiğinde tablo dört yerde değişiyor. Kullanıcı yazması alan sistem sayısı üçten ikiye iniyor; üçe değil ikiye, çünkü üçüncü yazıcı kurumun yetki sınırının dışındadır. Çakışan çift sayısı yüz otuz birden doksan beşe düşüyor. Telefon alanındaki çakışma tamamen kayboluyor: iki yazılabilir sistem artık aynı yazma yolundan beslendiği için o alanda iki farklı gerçek üretilemiyor.

Ad ve adres alanlarında çakışma azalıyor ama sıfırlanmıyor — altmış ikiden elli üçe, elli dörtten kırk ikiye. Kalan çakışmaların tamamı kurum içi kopyalarla belediyenin kopyası arasındadır.

Beşinci satır dersin en sert sayısıdır: kalan tutarsızlık iki düzende de tam olarak kırk sekiz. Bu bir rastlantı değil, düzeneğin yapısal sonucudur. Uzlaştırmanın kazananı, o alanın en son yazılmış değeridir; hangi ekrandan geldiği ve hangi sisteme düştüğü kazananı değiştirmez. Kazanan kimlik servisinden gelmediği her durumda o servisin kopyası yanlış kalır ve dışarıdan yazılamadığı için düzeltilemez. Altın kayıt seçimi bu kırk sekiz çakışmanın bir tanesini bile azaltmıyor.

Buradan ana veri yönetiminin gerçek sınırı çıkıyor. Altın kayıt, yazma yetkisinin ulaştığı yüzeyde tutarlılık üretir. O yüzeyin dışında kalan her kopya için üretebileceği tek şey, tutarsızlığın nerede olduğunu bilmektir. Kırk sekiz kayıt için yapılabilecek şey onları düzeltmek değil, raporlanabilir hâle getirmek ve kurum içi kararların hangi kopyaya güveneceğini yazılı hâle getirmektir.

Seçimin Ödettiği

İkinci ve altıncı satırlar bedeli veriyor. Olay başına yazma adımı 1,00’dan 1,61’e çıkıyor. Artış iki kat değil, çünkü yalnız birden fazla yazılabilir sistemin taşıdığı alanlar yayılıyor; elektronik posta yazmaları tek adımda kalıyor. Yazma yolunun uzaması ölçülebilir bir gecikme olarak da geri döner: kullanıcı artık kendi sisteminin veritabanına değil, başka bir birimin sistemine yazar ve o yazma başarılı olana kadar bekler.

Altıncı satır bunun daha sert biçimidir. Üyelik sistemi kapalıyken dağıtık düzende yedi yüz yirmi yazmanın dört yüz doksan altısı kabul edilirken, altın kayıt düzeninde yalnız iki yüz otuz sekizi kabul ediliyor — o da belediyenin kendi ekranından gelenlerdir. Kurumun bütün üye yazmaları tek bir birimin sistemine bağlanmıştır. Dağıtık düzende üyelik sisteminin kapalı olması ödünç servisinin üye adresini güncellemesini engellemiyordu; altın kayıt düzeninde engelliyor.

Ödenen bedel yalnız teknik de değil. Kaynak sistem seçmek, bir birimin sistemini öteki birimlerin çalışma önkoşulu hâline getirir: erişilebilirlik hedefi, bakım penceresi ve sürüm takvimi artık o birimin tek başına vereceği kararlar olmaktan çıkar. Kurum ölçeğinde altın kayıt kararı bir veri kararı gibi görünür, ama ödediği şey bir bağımlılık ve bir koordinasyon yükümlülüğüdür.

Özet

• Aynı üye kaydı üç sistemde tutulduğunda 720 yazma olayı dağıtık düzende 131 çakışan (üye, alan) çifti üretiyor; çakışma yalnız birden fazla sistemin yazdığı alanlarda doğuyor.
• Tek sistemde duran elektronik posta alanı hiçbir düzende çakışmıyor; iki sistemde duran telefon alanı altın kayıt düzeninde 15 çakışmadan 0’a iniyor.
• Uzlaştırma turu dağıtık düzende 95, altın kayıt düzeninde 94 alan değerini düzeltiyor; kalan tutarsızlık iki düzende de 48 ve tamamı dışarıdan yazılamayan sistemin taşıdığı iki alandadır.
• Altın kayıt seçimi çakışmayı 131’den 95’e düşürüyor ama kalan tutarsızlığı bir tane bile azaltmıyor: düzeltme ancak yazma yetkisinin ulaştığı yüzeyde çalışır.
• Seçimin bedeli olay başına yazma adımının 1,00’dan 1,61’e çıkması ve kaynak sistem kapalıyken kabul edilen yazmanın 496/720’den 238/720’ye düşmesidir.

Sonraki Adım

Üç ders boyunca bütün ölçümler işletim yolunda kaldı: bir kayıt yazıldı, bir bağdan geçti, bir sistemde okundu. Yönetim birimi ise bunların hiçbirini tek tek sormuyor; dönemlik ödünç sayısını, şube başına gecikme oranını ve üyelik hareketlerini birlikte istiyor ve bu soruların yanıtı üç ayrı sistemin verisini yan yana koymayı gerektiriyor. Bu soruların işletim sistemleri üzerinde koşturulması hiç ölçülmedi: raporlama sorgusunun kaynak sisteme bindirdiği yük, üç sistemin farklı alan adlarının tek bir çözümleme biçimine getirilmesi ve bu dönüştürmenin sonucun tazeliğine eklediği gecikme. Sonraki ders çözümleme yükünü işletim yolundan ayırır ve bu üç niceliği sayar.