Hesap ve Kuruluş Yapısı

Önceki iki ders kimliğin nereden geldiğini ve ne yapabildiğini ölçtü; ikisi de tek bir sınırın içinde kaldı. Politika daraltıldıktan sonra bile bir soru yanıtsız duruyor: bu iş yükleri hangi sınırın içinde? Aynı sekiz iş yükü ve üç ortam üç ayrı yapıda kurulabilir — hepsi tek hesapta, ortama göre ayrılmış hesaplarda ya da iş yüküne göre ayrılmış hesaplarda. Bu ders üçünü yan yana kuruyor ve dört şey sayıyor: patlama yarıçapı, kotanın kaç iş yükü arasında paylaşıldığı, faturanın kaç kaleme ayrıştığı ve kaç hesapla kaç politika kopyasının yönetildiği. Sonda kuruluş düzeyi koruma bandının ne kesip ne kesemediği ölçülüyor.

• BI37. Sekiz iş yükü, üç ortam, sekiz kaynak ailesi ve yirmi dört kaynak kurgusal bölgesel ölçüm ağına aittir; ölçülen şey node ile yazılan modeldir.
• BI38. Patlama yarıçapı iki kümenin birleşimidir: kimliğin politikayla eriştiği kaynaklar ve hesabının içindeki kaynaklar. Hesap içinde yükselme mümkün, hesap sınırı geçilmez varsayıldı.
• BI39. Kota hesap başına verildi ve tek bir sayı olarak modellendi. Kurgu birimdir; gerçek bir fiyat ya da sınır listesi değildir.
• BI40. Talep sabittir; ani yük, geri çekilme ve kuyruklanma modellenmiyor. Bunlar sınıra çarpma anını değiştirir, hangi hesabın çarptığını değiştirmez.
• BI41. Bir iş yükünün fatura payı ancak hesabında tek başınaysa doğrudan okunabilir sayıldı; etiketleme yoluyla dağıtım bu derste ölçülmüyor.
• BI42. Kuruluş düzeyi koruma bandı hesaba iliştirilir ve hesabın içini ayıramaz. Bu bir model kararıdır; bandın ortama göre kesebilmesi hesap sınırının ortamı ayırmasına bağlıdır.

Aynı Küme, Üç Yapı

Model kaynakları aile ve ortam çiftiyle adlandırıyor, her ailenin bir sahip iş yükü var ve üç yapı tek bir soruya farklı yanıt veriyor: bir iş yükü hangi hesaba düşüyor. Geri kalanı — politika, kaynak, talep — üç yapıda aynı.

// hesap.mjs — ayni is yuku kumesi uc hesap yapisinda kurulur; kurgusal olcum agi modeli
export const ORTAM = ['gelistirme', 'hazirlik', 'uretim'];
export const AILE = ['olcum', 'kuyruk', 'arsiv', 'fatura', 'is-emri', 'gunluk', 'yapilandirma', 'posta'];
export const IZIN = {                                // aile -> ailenin acilan izinleri
  olcum: ['oku', 'yaz', 'sil'], kuyruk: ['oku', 'yaz', 'yonet'], arsiv: ['oku', 'yaz', 'sil'],
  fatura: ['oku', 'yaz'], 'is-emri': ['oku', 'yaz'], gunluk: ['oku', 'yaz'],
  yapilandirma: ['oku', 'yaz'], posta: ['gonder'],
};
export const VERILEN = {                             // is yuku -> erisimi olan aileler
  'okuma-toplayici': ['olcum', 'kuyruk'], 'dogrulayici': ['olcum', 'kuyruk'],
  'gunluk-tasiyici': ['gunluk', 'yapilandirma'], 'faturalama': ['fatura', 'posta', 'arsiv'],
  'is-emri': ['is-emri', 'kuyruk', 'posta'], 'gecelik-toplu-is': ['olcum', 'arsiv', 'fatura'],
  'arsivleyici': ['arsiv'], 'rapor-uretici': ['fatura', 'arsiv', 'gunluk'],
};
export const SAHIP = {                               // kaynak ailesinin sahibi is yuku
  olcum: 'okuma-toplayici', kuyruk: 'dogrulayici', arsiv: 'arsivleyici', fatura: 'faturalama',
  'is-emri': 'is-emri', gunluk: 'gunluk-tasiyici', yapilandirma: 'gunluk-tasiyici', posta: 'faturalama',
};
export const GERCEK = {                              // gercekten kullanilan yollar
  'okuma-toplayici': ['olcum-yaz', 'kuyruk-yaz', 'olcum-oku'],
  'dogrulayici': ['olcum-oku', 'kuyruk-oku', 'olcum-yaz', 'olcum-sil'],
  'gunluk-tasiyici': ['gunluk-yaz', 'yapilandirma-oku'],
  'faturalama': ['fatura-oku', 'fatura-yaz', 'posta-gonder', 'arsiv-oku'],
  'is-emri': ['is-emri-yaz', 'is-emri-oku', 'kuyruk-oku', 'posta-gonder'],
  'gecelik-toplu-is': ['olcum-oku', 'arsiv-yaz', 'fatura-oku', 'olcum-sil'],
  'arsivleyici': ['arsiv-oku', 'arsiv-yaz', 'arsiv-sil'],
  'rapor-uretici': ['fatura-oku', 'arsiv-oku', 'gunluk-oku'],
};
export const OZNE = Object.keys(VERILEN);
export const TALEP = {                               // kurgu birim: dakikada istek, uretim olceginde
  'okuma-toplayici': 420, 'dogrulayici': 260, 'gunluk-tasiyici': 90, 'faturalama': 140,
  'is-emri': 110, 'gecelik-toplu-is': 380, 'arsivleyici': 70, 'rapor-uretici': 60,
};
export const ORTAM_OLCEK = { gelistirme: 0.1, hazirlik: 0.3, uretim: 1 };
export const KOTA = 1000;                            // hesap basina kota, kurgu birim
export const KAYNAK = AILE.flatMap((a) => ORTAM.map((o) => `${a}@${o}`));
export const KIMLIK = OZNE.flatMap((s) => ORTAM.map((o) => `${s}@${o}`));
// Uc yapi: bir is yukunun hangi hesaba dustugu.
export const YAPI = {
  'tek-hesap': () => 'tek', 'ortama-gore': (s, o) => o, 'is-yukune-gore': (s, o) => `${s}@${o}`,
};
export const kimlikHesap = (y, k) => YAPI[y](k.split('@')[0], k.split('@')[1]);
export const kaynakHesap = (y, r) => YAPI[y](SAHIP[r.split('@')[0]], r.split('@')[1]);
// Politikayla erisilen kaynaklar: kimligin kendi ortamindaki verilen aileler.
export const politikaKaynak = (k) => VERILEN[k.split('@')[0]].map((a) => `${a}@${k.split('@')[1]}`);
// Hesabindaki kaynaklar: ele gecen kimlik hesap icinde yukselirse acilan kume.
export const hesapKaynak = (y, k) => KAYNAK.filter((r) => kaynakHesap(y, r) === kimlikHesap(y, k));
export const patlama = (y, k) => new Set([...hesapKaynak(y, k), ...politikaKaynak(k)]).size;
// Kurulus duzeyi koruma bandi: [izin, hangi ortamda kesilir]
export const UST_SINIR = [
  ['olcum-sil', (o) => o !== 'uretim'], ['arsiv-sil', (o) => o !== 'uretim'],
  ['yapilandirma-yaz', () => true],
];
export const verilenIzin = (s) => VERILEN[s].flatMap((a) => IZIN[a].map((x) => `${a}-${x}`));

// kosum1.mjs — patlama yaricapi: bir kimlik ele gecerse kac kaynak aciliyor
import { KAYNAK, KIMLIK, YAPI, kimlikHesap, hesapKaynak, patlama, politikaKaynak } from './hesap.mjs';

console.log(`kaynak ${KAYNAK.length}, kimlik ${KIMLIK.length}\n`);
console.log('yapi              hesap  en genis  ortalama  (kimlik, kaynak)  politika');
console.log('                         patlama   patlama   kalemi            kadari');
for (const y of Object.keys(YAPI)) {
  const p = KIMLIK.map((k) => patlama(y, k));
  const hesap = new Set(KIMLIK.map((k) => kimlikHesap(y, k))).size;
  const pol = KIMLIK.reduce((a, k) => a + politikaKaynak(k).length, 0);
  console.log(`${y.padEnd(18)}${String(hesap).padStart(5)}${String(Math.max(...p)).padStart(10)}` +
    `${(p.reduce((a, x) => a + x, 0) / p.length).toFixed(1).padStart(10)}` +
    `${String(p.reduce((a, x) => a + x, 0)).padStart(18)}${String(pol).padStart(10)}`);
}
console.log('\nis yukune gore yapida uretim kimlikleri  hesabinda  politikayla  patlama');
for (const k of KIMLIK.filter((x) => x.endsWith('uretim')))
  console.log(`  ${k.padEnd(38)}${String(hesapKaynak('is-yukune-gore', k).length).padStart(9)}` +
    `${String(politikaKaynak(k).length).padStart(13)}${String(patlama('is-yukune-gore', k)).padStart(9)}`);

kaynak 24, kimlik 24

yapi              hesap  en genis  ortalama  (kimlik, kaynak)  politika
                         patlama   patlama   kalemi            kadari
tek-hesap             1        24      24.0               576        57
ortama-gore           3         8       8.0               192        57
is-yukune-gore       24         3       2.4                57        57

is yukune gore yapida uretim kimlikleri  hesabinda  politikayla  patlama
  okuma-toplayici@uretim                        1            2        2
  dogrulayici@uretim                            1            2        2
  gunluk-tasiyici@uretim                        2            2        2
  faturalama@uretim                             2            3        3
  is-emri@uretim                                1            3        3
  gecelik-toplu-is@uretim                       0            3        3
  arsivleyici@uretim                            1            1        1
  rapor-uretici@uretim                          0            3        3

Tek hesapta yirmi dört kimliğin her biri, ele geçirildiğinde yirmi dört kaynağın hepsini açıyor. Ortama göre ayrıldığında bu sayı sekize, iş yüküne göre ayrıldığında en fazla üçe iniyor. Toplam (kimlik, kaynak) kalemi beş yüz yetmiş altıdan elli yediye düşüyor — on kat.

Son sütun yapının nerede durduğunu söylüyor. Politikanın tek başına verdiği erişim üç yapıda da elli yedi kalemdir; hesap yapısı bu sayıyı değiştirmiyor, yalnız üstüne ne eklendiğini belirliyor. Tek hesapta beş yüz on dokuz kalem hesap sınırından geliyor; iş yüküne göre ayrılmış yapıda ekleme sıfırdır. Daraltılmış bir politika ancak hesap sınırı onu destekliyorsa gerçekten dar demektir.

Alt blok nedenini gösteriyor. Gecelik toplu iş ve rapor üretici hiçbir kaynağa sahip değil; hesaplarında sıfır kaynak var, yarıçapları tamamen politikadan geliyor. Arşivleyici tek aileye sahip ve tek aileye erişiyor, yarıçapı bir. Yapının ne kadar sıkabileceğini sahiplik dağılımı belirliyor.

Kota Paylaşımı ve Kalan

Hesap yalnız bir güvenlik sınırı değil, aynı zamanda bir kota kabıdır.

// kosum2.mjs — kota paylasimi: hangi hesap sinira carpiyor, sinira kac birim kaliyor
import { KIMLIK, YAPI, KOTA, TALEP, ORTAM_OLCEK, kimlikHesap } from './hesap.mjs';

const talep = (k) => Math.round(TALEP[k.split('@')[0]] * ORTAM_OLCEK[k.split('@')[1]]);
console.log(`hesap basina kota ${KOTA} kurgu birim; toplam talep ${KIMLIK.reduce((a, k) => a + talep(k), 0)}\n`);
console.log('yapi              hesap  kotayi paylasan  en dolu   sinira  asan');
console.log('                         en cok kimlik    hesap     kalan   hesap');
for (const y of Object.keys(YAPI)) {
  const h = new Map();
  for (const k of KIMLIK) {
    const a = kimlikHesap(y, k);
    h.set(a, [(h.get(a)?.[0] ?? 0) + talep(k), (h.get(a)?.[1] ?? 0) + 1]);
  }
  const yuk = [...h.values()], enDolu = Math.max(...yuk.map((v) => v[0]));
  console.log(`${y.padEnd(18)}${String(h.size).padStart(5)}${String(Math.max(...yuk.map((v) => v[1]))).padStart(17)}` +
    `${String(enDolu).padStart(10)}${String(KOTA - enDolu).padStart(9)}` +
    `${String(yuk.filter((v) => v[0] > KOTA).length).padStart(6)}`);
}
console.log('\nortama gore yapida hesap yuku:');
for (const o of ['gelistirme', 'hazirlik', 'uretim']) {
  const t = KIMLIK.filter((k) => k.endsWith(o)).reduce((a, k) => a + talep(k), 0);
  console.log(`  ${o.padEnd(12)}talep ${String(t).padStart(4)}  kalan ${String(KOTA - t).padStart(5)}`);
}

hesap basina kota 1000 kurgu birim; toplam talep 2142

yapi              hesap  kotayi paylasan  en dolu   sinira  asan
                         en cok kimlik    hesap     kalan   hesap
tek-hesap             1               24      2142    -1142     1
ortama-gore           3                8      1530     -530     1
is-yukune-gore       24                1       420      580     0

ortama gore yapida hesap yuku:
  gelistirme  talep  153  kalan   847
  hazirlik    talep  459  kalan   541
  uretim      talep 1530  kalan  -530

Tek hesapta yirmi dört kimlik aynı bin birimlik kotayı paylaşıyor ve toplam talep iki bin yüz kırk iki. Sınıra kalan eksi bin yüz kırk iki birim; yani hesap kotayı iki kattan fazla aşıyor. Aşmanın sonucu bir iş yükünün değil hepsinin yavaşlamasıdır — geliştirme ortamında koşan bir sınama, üretim ortamındaki toplayıcıyla aynı kabın içindedir.

Ortama göre ayrıldığında kap üçe bölünüyor ve asıl bilgi alt blokta. Geliştirmede sekiz yüz kırk yedi, hazırlıkta beş yüz kırk bir birim boşta duruyor; üretim ise beş yüz otuz birim aşıyor. Toplam talep değişmedi, yalnız nereye düştüğü değişti — ve boşta duran bin üç yüz seksen sekiz birim üretimin eksiğini kapatmıyor, çünkü kotalar devredilemiyor.

İş yüküne göre ayrılmış yapıda hiçbir hesap sınıra çarpmıyor; en dolu hesapta beş yüz seksen birim kalıyor. Bedeli yirmi dört ayrı kotadır — her biri ayrı izlenmesi, artırılması ve unutulması gereken bir sınır. Kota paylaşımı azaldıkça çarpma riski düşüyor, sınır sayısı artıyor.

Fatura ve Yönetim Yükü

Hesap sınırı üçüncü bir şeyi daha belirliyor: faturanın kaç kaleme ayrıldığını ve kaç politika belgesinin bakımını.

// kosum3.mjs — faturanin ayrismasi ve yonetim yuku: kac hesap, kac politika kopyasi
import { KIMLIK, YAPI, kimlikHesap, kaynakHesap, politikaKaynak } from './hesap.mjs';

console.log('yapi              fatura  dogrudan  kimlik    kaynak    toplam');
console.log('                  kalemi  okunan    temelli   temelli   politika');
for (const y of Object.keys(YAPI)) {
  const h = new Map();
  for (const k of KIMLIK) h.set(kimlikHesap(y, k), (h.get(kimlikHesap(y, k)) ?? 0) + 1);
  const yalniz = KIMLIK.filter((k) => h.get(kimlikHesap(y, k)) === 1).length;
  const capraz = KIMLIK.reduce((a, k) =>
    a + politikaKaynak(k).filter((r) => kaynakHesap(y, r) !== kimlikHesap(y, k)).length, 0);
  console.log(`${y.padEnd(18)}${String(h.size).padStart(6)}${`${yalniz}/${KIMLIK.length}`.padStart(10)}` +
    `${String(KIMLIK.length).padStart(10)}${String(capraz).padStart(10)}${String(KIMLIK.length + capraz).padStart(10)}`);
}
console.log('\nis yukune gore yapida capraz hesap erisimi:');
for (const k of KIMLIK.filter((x) => x.endsWith('uretim'))) {
  const c = politikaKaynak(k).filter((r) => kaynakHesap('is-yukune-gore', r) !== kimlikHesap('is-yukune-gore', k));
  console.log(`  ${k.padEnd(26)}${String(c.length).padStart(2)}  ${c.map((r) => r.split('@')[0]).join(', ') || '-'}`);
}

yapi              fatura  dogrudan  kimlik    kaynak    toplam
                  kalemi  okunan    temelli   temelli   politika
tek-hesap              1      0/24        24         0        24
ortama-gore            3      0/24        24         0        24
is-yukune-gore        24     24/24        24        33        57

is yukune gore yapida capraz hesap erisimi:
  okuma-toplayici@uretim     1  kuyruk
  dogrulayici@uretim         1  olcum
  gunluk-tasiyici@uretim     0  -
  faturalama@uretim          1  arsiv
  is-emri@uretim             2  kuyruk, posta
  gecelik-toplu-is@uretim    3  olcum, arsiv, fatura
  arsivleyici@uretim         0  -
  rapor-uretici@uretim       3  fatura, arsiv, gunluk

Fatura kalemi hesap sayısıdır: bir, üç, yirmi dört. İlk iki yapıda hiçbir iş yükünün payı hesap düzeyinde okunamıyor; ortama göre ayrılmış yapıda ortam toplamı okunuyor ama iş yükü payı okunmuyor. Üçüncü yapıda yirmi dördün yirmi dördü okunuyor.

Sağdaki üç sütun bedeli veriyor. Kimlik temelli politika sayısı üç yapıda da yirmi dörttür. Değişen kaynak temelli politikadır: iş yüküne göre ayrılmış yapıda otuz üç çapraz hesap erişimi doğuyor ve her biri kaynağın hesabında ayrıca yazılması gereken bir belge. Toplam politika belgesi yirmi dörtten elli yediye çıkıyor.

Alt blok çapraz erişimin nerede biriktiğini gösteriyor. Hiçbir kaynağa sahip olmayan iki iş yükü üçer çapraz erişim taşıyor; günlük taşıyıcı ve arşivleyici hiç taşımıyor, çünkü eriştiği her aileye sahipler. Yapıyı bölmenin maliyeti tam olarak sahiplikle erişimin örtüşmediği kadardır.

Kuruluş Düzeyi Koruma Bandı

Hesapların üstüne bir üst sınır politikası konabilir: hesap içinde ne yazılırsa yazılsın, bandın kestiği izin geçmez. Bandın gücü hesap sınırına bağlıdır, çünkü band hesaba iliştirilir.

// kosum4.mjs — kurulus duzeyi koruma bandi: ne kesiyor, ne kesemiyor
import { ORTAM, KIMLIK, YAPI, UST_SINIR, GERCEK, verilenIzin, kimlikHesap, patlama } from './hesap.mjs';

const ayirir = (y) => {                              // hesap sinirlari ortami ayiriyor mu
  const h = new Map();
  for (const k of KIMLIK) {
    const a = kimlikHesap(y, k);
    h.set(a, new Set([...(h.get(a) ?? []), k.split('@')[1]]));
  }
  return [...h.values()].every((s) => s.size === 1);
};
const uygula = (y) => UST_SINIR.filter(([, ko]) => ayirir(y) || ORTAM.every(ko));
const verilenToplam = KIMLIK.reduce((a, k) => a + verilenIzin(k.split('@')[0]).length, 0);
console.log(`verilen (kimlik, izin) kalemi ${verilenToplam}\n`);
console.log('yapi              ortam      kesilen  verilenin  durdurulan  banttan sonra');
console.log('                  ayriliyor  kalem    yuzdesi    mesru yol   en genis patlama');
for (const y of Object.keys(YAPI)) {
  let kes = 0, dur = 0;
  for (const [izin, ko] of uygula(y))
    for (const k of KIMLIK) {
      const [s, o] = k.split('@');
      if (!ko(o) || !verilenIzin(s).includes(izin)) continue;
      kes++; if (GERCEK[s].includes(izin)) dur++;
    }
  console.log(`${y.padEnd(18)}${(ayirir(y) ? 'evet' : 'hayir').padEnd(11)}${String(kes).padStart(5)}` +
    `${`%${Math.round((kes / verilenToplam) * 100)}`.padStart(11)}${String(dur).padStart(11)}` +
    `${String(Math.max(...KIMLIK.map((k) => patlama(y, k)))).padStart(18)}`);
}
console.log('\nbant kurallarinin tek tek kestigi kalem (ortam ayrilan yapida):');
for (const [izin, ko] of UST_SINIR) {
  const k = KIMLIK.filter((x) => ko(x.split('@')[1]) && verilenIzin(x.split('@')[0]).includes(izin));
  console.log(`  ${izin.padEnd(18)}${String(k.length).padStart(3)} kalem, mesru ` +
    `${k.filter((x) => GERCEK[x.split('@')[0]].includes(izin)).length}`);
}

verilen (kimlik, izin) kalemi 138

yapi              ortam      kesilen  verilenin  durdurulan  banttan sonra
                  ayriliyor  kalem    yuzdesi    mesru yol   en genis patlama
tek-hesap         hayir          3         %2          0                24
ortama-gore       evet          17        %12          6                 8
is-yukune-gore    evet          17        %12          6                 3

bant kurallarinin tek tek kestigi kalem (ortam ayrilan yapida):
  olcum-sil           6 kalem, mesru 4
  arsiv-sil           8 kalem, mesru 2
  yapilandirma-yaz    3 kalem, mesru 0

Band üç kural taşıyor: üretim dışında ölçüm silme, üretim dışında arşiv silme ve her yerde yapılandırma yazma. Ortamı ayıran iki yapıda üçü de uygulanabiliyor ve yüz otuz sekiz kalemin on yedisini, yani yüzde on ikisini kesiyor. Tek hesapta yalnız üçüncü kural uygulanabiliyor: hesap sınırı ortamı ayırmadığı için “üretim dışında” koşulu bir yere iliştirilemiyor ve kesilen kalem üçte kalıyor.

Dördüncü sütun bandın bedelini veriyor: kesilen on yedi kalemin altısı meşru bir yolu durduruyor. Alt blok bunu kural kural ayırıyor — ölçüm silme altı kalem kesiyor, dördü meşru; arşiv silme sekiz kesiyor, ikisi meşru; yapılandırma yazma üç kesiyor, hiçbiri meşru değil. Üçüncü kural bedelsiz, ilk ikisi değil.

Son sütun bandın kesemediğini gösteriyor. Band uygulandıktan sonra da en geniş patlama yarıçapı yirmi dört, sekiz ve üç kalıyor. Band izinleri keser, sınırları kurmaz: silme iznini kaldırmak ele geçen bir kimliğin kaç kaynağa dokunabildiğini değiştirmiyor. Onu değiştiren tek şey kaynakların hangi hesapta durduğudur.

Özet

• Aynı 24 kaynak ve 24 kimlik üç yapıda kurulduğunda en geniş patlama yarıçapı 24 → 8 → 3; toplam (kimlik, kaynak) kalemi 576’dan 57’ye düşüyor.
• Politikanın tek başına verdiği erişim üç yapıda da 57 kalemdir; tek hesapta üstüne 519 kalem ekleniyor, iş yüküne göre ayrılmış yapıda ekleme 0. Daraltılmış politika ancak hesap sınırı destekliyorsa gerçekten dardır.
• Kota hesap başına 1.000 kurgu birim: tek hesapta sınır 1.142 birim aşılıyor; ortama göre üretim hesabı 530 aşarken geliştirme ve hazırlıkta 1.388 birim boşta kalıyor ve devredilemiyor; iş yüküne göre hiçbir hesap aşmıyor, en dolusunda 580 birim kalıyor.
• Fatura kalemi 1 → 3 → 24; iş yükü payı ilk iki yapıda 0/24, üçüncüde 24/24 doğrudan okunuyor. Bedeli politika sayısıdır: 24 belge 57’ye çıkıyor, çünkü 33 çapraz hesap erişimi doğuyor.
• Kuruluş düzeyi koruma bandı ortamı ayıran yapılarda 138 kalemin 17’sini (%12) kesiyor ve 6 meşru yolu durduruyor; tek hesapta ortam koşulu iliştirilemediği için yalnız 3 kalem kesiyor. Gücü kendi metninden değil hesap yapısından geliyor — ve kesemediği şey patlama yarıçapıdır: banttan sonra da en geniş yarıçap 24 / 8 / 3 kalıyor.

Sonraki Adım

Bu konu bir soruyu sonuna kadar götürdü: kim ne yapabiliyor. Kullanıcılar ve roller yazıldı, politikalar iki yönden değerlendirildi, yetki geçici hâle geldi, iş yüküne kimlik verildi, verilen izin kullanılan izinle karşılaştırıldı ve hesaplar ayrıldı. Ama bütün bu ölçümler tek bir fiile bakıyordu: yapmak. Erişim daraltıldıktan sonra bile listede kalan özneler var — patlama yarıçapı sıfır olmadı, üç oldu. Sorulmayan soru şudur: o üç kaynağa erişebilen bir özne veriyi okuduğunda ne görecek? Diskte duran kayıt açık mı, kablodan geçen istek okunabilir mi, kaydı çözen anahtar kimde duruyor? Sonraki ders erişimi değil, erişilenin kendisini ölçüyor.