Teslimat Ölçütleri

Önceki ders dört ölçütü haritanın sonucu olarak okudu: harita değişti, ölçütler onu izledi. Ama ölçütler bağımsız birer sonuç değildir; bir küme oluştururlar ve aynı karar hepsini birden oynatır. Bu ders o kümeyi tek koşumdan okur.

Dört ölçüt şunlardır. Dağıtım sıklığı: birim zamanda üretime çıkan yayın sayısı. Öncü süre: bir değişikliğin akışa girişinden üretimde kalıcı olarak yer almasına kadar geçen süre. Geri dönüş oranı: üretimde hata çıkaran, yani başarısız değişikliğin payı. Kurtarma süresi: hatanın üretime çıkışından servisin düzelmesine kadar geçen süre. M20/K05’te teslim süresi bir iş kaleminin ekip akışında başlangıçtan bitişe geçirdiği süreydi; buradaki öncü süre değişikliğin üretimde kalıcı yer almasını bekler — geri alınan değişiklikte sayaç durmaz.

Kümenin Kurulması

Örnek yine kurgu bölgesel ölçüm ağıdır; ağ da yayın düzeni de kurgudur. KA19: altmış değişiklik dörder adım arayla akışa girer. KA20: her değişiklik için iki zar koşulsuz atılır — kusurlu olup olmadığı (oran 0,20) ve kusurun kapıda yakalanıp yakalanmayacağı (oran 0,60); tohum 20260804’tür ve zar sırası koşumdan koşuma değişmez. KA21: değişiklikler bir partide toplanır; parti dolunca ya da ilk kalem 30 adım bekleyince hazırlık başlar. Aynı anda tek yayın hazırlanır ve hazırlık 4 artı parti büyüklüğü kadar adım tutar. KA22: kapı varsa hazırlığa 5 adım ekler ve yayından önce çalışır; tuttuğu kusur partiden çıkarılır, 6 adımda düzeltilip kuyruğa geri girer. KA23: yayında yakalanmamış kusur varsa üretimde hata olur; otomatik geri alma yokken sağlam değişiklikler üretimde kalır, kusurlu olan 12 adım tespit ve 6 adım düzeltmeden sonra kuyruğa döner ve kurtarma süresi düzeltme yayınlanana kadar sayılır. KA24: otomatik geri alma varsa yayının tamamı 3 adım tespit ve 4 adım geri alma ile geri alınır; kurtarma süresi 7 adımdır ama partideki bütün değişiklikler kuyruğa döner. KA25: düzeltilen değişiklik yeniden kusurlu olmaz.

Yayın düzeni ve kararlar süreç içi bir modeldir; gerçek bir yayın kaydı yoktur.

// olcut/kume.mjs — dort teslimat olcutunun bagli kume olarak modeli: gercek bir yayin kaydi yok,
// adimlar veri yapisidir. Rastgelelik uretecle yazilir, tohum gorunur.

export const N = 60, VARIS = 4, LIMIT = 4000, TOHUM = 20260804;
export const KUSUR = 0.20, KAPI_YAKALAMA = 0.60;   // kusur orani ve kapinin yakalama orani
export const H0 = 4, H1 = 1, KAPI = 5;             // hazirlik = H0 + H1 * parti (+ kapi)
export const TESPIT = 12, DUZELT = 6;              // elle tespit ve duzeltme
export const TESPIT_OTO = 3, GERI = 4;             // otomatik tespit ve geri alma
export const MAKS_BEKLEME = 30;                    // yarim parti bu kadar bekleyince yayina cikar

export function uretec(tohum) {                    // dogrusal eslesmeli uretec
  let x = tohum >>> 0;
  return () => ((x = (x * 1664525 + 1013904223) >>> 0) / 2 ** 32);
}

export function kos({ parti = 8, kapi = false, otomatik = false } = {}) {
  const zar = uretec(TOHUM);
  const D = Array.from({ length: N }, (_, i) => ({ i, varis: i * VARIS, hazir: i * VARIS,
    durum: "yolda", kusur: zar() < KUSUR, yakalanir: zar() < KAPI_YAKALAMA,
    bitis: null, hataAt: null, kurtarma: null, geriAlindi: 0, kuyrukAt: 0 }));
  const S = { yayin: 0, bozukYayin: 0, kapidaYakalanan: 0, geriAlma: 0, uretimHatasi: 0,
    partiToplam: 0, geriKusurlu: 0, geriMasum: 0 };
  let aktif = null;

  const yayinBitir = (a, t) => {
    let grup = a.grup;
    if (kapi) {                                    // kapi kusurun bir bolumunu yayindan once tutar
      const tutulan = grup.filter((d) => d.kusur && d.yakalanir);
      S.kapidaYakalanan += tutulan.length;
      for (const d of tutulan) { d.durum = "yolda"; d.hazir = t + DUZELT; d.kusur = false; }
      grup = grup.filter((d) => !tutulan.includes(d));
    }
    S.yayin++; S.partiToplam += grup.length;
    const bozuk = grup.filter((d) => d.kusur);
    if (!bozuk.length) { for (const d of grup) { d.durum = "bitti"; d.bitis = t; } return; }
    S.bozukYayin++; S.uretimHatasi += bozuk.length;
    if (!otomatik) {                               // saglam degisiklik uretimde kalir
      for (const d of grup) {
        if (!d.kusur) { d.durum = "bitti"; d.bitis = t; continue; }
        d.hataAt = t; d.kusur = false; d.durum = "yolda"; d.hazir = t + TESPIT + DUZELT;
      }
      return;
    }
    S.geriAlma++;                                  // butun yayin geri alinir, masumlar da doner
    for (const d of grup) {
      const bu = d.kusur;
      if (bu) { d.hataAt = t; d.kusur = false; d.kurtarma = TESPIT_OTO + GERI; S.geriKusurlu++; }
      else S.geriMasum++;
      d.geriAlindi++; d.durum = "yolda";
      d.hazir = t + TESPIT_OTO + GERI + (bu ? DUZELT : 0);
    }
  };

  for (let t = 0; t <= LIMIT; t++) {
    for (const d of D) if (d.durum === "yolda" && d.hazir <= t) { d.durum = "kuyrukta"; d.kuyrukAt = t; }
    if (aktif && aktif.bitis === t) { yayinBitir(aktif, t); aktif = null; }
    if (aktif) continue;                           // ayni anda tek yayin hazirlanir
    const K = D.filter((d) => d.durum === "kuyrukta").sort((a, b) => a.kuyrukAt - b.kuyrukAt || a.i - b.i);
    if (!K.length) continue;
    if (K.length < parti && t - K[0].kuyrukAt < MAKS_BEKLEME) continue;
    const grup = K.slice(0, parti);
    for (const d of grup) d.durum = "yayinda";
    aktif = { grup, bitis: t + H0 + H1 * grup.length + (kapi ? KAPI : 0) };
  }
  for (const d of D) if (d.hataAt !== null && d.kurtarma === null && d.bitis !== null)
    d.kurtarma = d.bitis - d.hataAt;               // elle kurtarma: duzeltme yayinlanana kadar
  return { D, S };
}

export const ort = (a) => (a.length ? (a.reduce((s, v) => s + v, 0) / a.length).toFixed(1) : "-");

export function olc(ayar) {
  const { D, S } = kos(ayar);
  const pencere = Math.max(...D.map((d) => d.bitis ?? 0));
  const kurtarmalar = D.filter((d) => d.kurtarma !== null).map((d) => d.kurtarma);
  return { D, S, pencere,
    dagitimSikligi: (100 * S.yayin / pencere).toFixed(1), yayin: S.yayin,
    ortParti: (S.partiToplam / S.yayin).toFixed(1),
    onculSure: ort(D.map((d) => d.bitis - d.varis)),
    geriDonusYayin: (100 * S.bozukYayin / S.yayin).toFixed(0) + "%",
    geriDonusDegisiklik: (100 * S.uretimHatasi / N).toFixed(0) + "%",
    kurtarma: ort(kurtarmalar), uretimHatasi: S.uretimHatasi,
    kapidaYakalanan: S.kapidaYakalanan, geriAlinan: D.reduce((s, d) => s + d.geriAlindi, 0),
    geriKusurlu: S.geriKusurlu, geriMasum: S.geriMasum, geriAlma: S.geriAlma,
    bitmeyen: D.filter((d) => d.bitis === null).length };
}

// olcut/olc.mjs — bir kararin dort olcutte olculen degisimi; tek olcutu iyilestirip otekini bozan.
import { N, TOHUM, KUSUR, olc, ort } from "./kume.mjs";

const yaz = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join(""));
const K = {
  "taban (parti 8)": {}, "parti 8 -> 2": { parti: 2 }, "parti 8 -> 1": { parti: 1 },
  "kapi eklendi": { kapi: true }, "otomatik geri alma": { otomatik: true },
  "parti 2 + otomatik": { parti: 2, otomatik: true },
  "parti 2 + kapi + otomatik": { parti: 2, kapi: true, otomatik: true },
};
const R = Object.fromEntries(Object.entries(K).map(([ad, a]) => [ad, olc(a)]));
const T = R["taban (parti 8)"];

console.log(`${N} degisiklik, kusur orani ${KUSUR}, tohum ${TOHUM}; ` +
  `kusurlu ${T.D.filter((d) => d.hataAt !== null).length}, ` +
  `bitmeyen ${Object.values(R).reduce((s, r) => s + r.bitmeyen, 0)}`);

const A = [-27, 11, 11, 12, 13, 11];
console.log("\n1. dort olcut bagli bir kume olarak");
yaz(A, "kosum", "dagitim", "oncu sure", "geri donus", "geri donus", "kurtarma");
yaz(A, "", "(100 adim)", "(adim)", "(yayin)", "(degisiklik)", "(adim)");
for (const [ad, r] of Object.entries(R))
  yaz(A, ad, r.dagitimSikligi, r.onculSure, r.geriDonusYayin, r.geriDonusDegisiklik, r.kurtarma);

const B = [-27, 8, 12, 15, 16, 13];
console.log("\n2. ayni kosumlarda kararin mekanigi");
yaz(B, "kosum", "yayin", "ort. parti", "uretim hatasi", "kapida tutulan", "geri alinan");
for (const [ad, r] of Object.entries(R))
  yaz(B, ad, r.yayin, r.ortParti, r.uretimHatasi, r.kapidaYakalanan, r.geriAlinan);

const C = [-27, 11, 12, 18, 12];
console.log("\n3. tabana gore ham fark (yonu her olcutte ayri okunur)");
yaz(C, "karar", "dagitim", "oncu sure", "geri donus/yayin", "kurtarma");
const sap = (r, k) => {
  const d = +r[k].replace("%", "") - +T[k].replace("%", "");
  return (d > 0 ? "+" : "") + d.toFixed(1);
};
for (const ad of Object.keys(R).slice(1))
  yaz(C, ad, sap(R[ad], "dagitimSikligi"), sap(R[ad], "onculSure"),
    sap(R[ad], "geriDonusYayin") + " puan", sap(R[ad], "kurtarma"));

const E = [-27, 11, 16, 10, 8, 22];
console.log("\n4. geri alinan yayinda masum degisiklik");
yaz(E, "kosum", "geri alma", "degisiklik-kez", "kusurlu", "masum", "masumun oncu suresi");
for (const ad of ["otomatik geri alma", "parti 2 + otomatik", "parti 2 + kapi + otomatik"]) {
  const r = R[ad], g = r.D.filter((d) => d.geriAlindi > 0 && d.hataAt === null);
  yaz(E, ad, r.geriAlma, r.geriAlinan, r.geriKusurlu, r.geriMasum,
    `${ort(g.map((d) => d.bitis - d.varis))} (taban ${T.onculSure})`);
}

60 degisiklik, kusur orani 0.2, tohum 20260804; kusurlu 12, bitmeyen 0

1. dort olcut bagli bir kume olarak
kosum                          dagitim  oncu sure  geri donus   geri donus   kurtarma
                            (100 adim)     (adim)     (yayin) (degisiklik)     (adim)
taban (parti 8)                    3.2       34.6         80%          20%       45.4
parti 8 -> 2                      13.5       14.9         31%          20%       26.3
parti 8 -> 1                      20.0       69.7         17%          20%       65.8
kapi eklendi                       3.1       36.8         40%           7%       54.8
otomatik geri alma                 5.1       50.6         50%          20%        7.0
parti 2 + otomatik                15.4       24.1         27%          20%        7.0
parti 2 + kapi + otomatik          9.0      109.3         11%           7%        7.0

2. ayni kosumlarda kararin mekanigi
kosum                         yayin  ort. parti  uretim hatasi  kapida tutulan  geri alinan
taban (parti 8)                  10         7.2             12               0            0
parti 8 -> 2                     36         2.0             12               0            0
parti 8 -> 1                     72         1.0             12               0            0
kapi eklendi                     10         6.4              4               8            0
otomatik geri alma               16         7.5             12               0           60
parti 2 + otomatik               41         2.0             12               0           22
parti 2 + kapi + otomatik        38         1.8              4               8            8

3. tabana gore ham fark (yonu her olcutte ayri okunur)
karar                          dagitim   oncu sure  geri donus/yayin    kurtarma
parti 8 -> 2                     +10.3       -19.7        -49.0 puan       -19.1
parti 8 -> 1                     +16.8       +35.1        -63.0 puan       +20.4
kapi eklendi                      -0.1        +2.2        -40.0 puan        +9.4
otomatik geri alma                +1.9       +16.0        -30.0 puan       -38.4
parti 2 + otomatik               +12.2       -10.5        -53.0 puan       -38.4
parti 2 + kapi + otomatik         +5.8       +74.7        -69.0 puan       -38.4

4. geri alinan yayinda masum degisiklik
kosum                        geri alma  degisiklik-kez   kusurlu   masum   masumun oncu suresi
otomatik geri alma                   8              60        12      48     64.5 (taban 34.6)
parti 2 + otomatik                  11              22        12      10     35.8 (taban 34.6)
parti 2 + kapi + otomatik            4               8         4       4    163.3 (taban 34.6)

Sayılar ölçüm sınıfındadır; girdileri yukarıdaki varsayımlardır.

Parti Küçültme: Oynayan Ölçüt, Oynamayan Alan

Tabanda parti sekizdir: on yayın, ortalama 7,2 değişiklik, dağıtım sıklığı 3,2, öncü süre 34,6 adım, kurtarma 45,4 adım. Yayın başına geri dönüş oranı %80’dir — on yayının sekizi içinde kusur taşır.

Parti ikiye indirilince dört ölçüt de tabana göre iyileşir: dağıtım sıklığı 13,5’e, öncü süre 14,9 adıma, kurtarma 26,3 adıma, yayın başına geri dönüş oranı %31’e gider. İkinci tablo bu tablonun altını çizer: üretimde çıkan hata sayısı 12’de kalır. Değişiklik başına geri dönüş oranı da %20’dir; tabanla aynı. Yayın başına oranın %80’den %31’e inmesi bir kalite kazanımı değil, aynı on iki hatanın daha çok yayına bölünmesidir. Bir ölçüt kırk dokuz puan iyileşirken alanda hiçbir şey değişmemiştir.

Partiyi bire indirmek bu sınırı gösterir. Dağıtım sıklığı 20,0’a, yayın sayısı 72’ye çıkar ve yayın başına geri dönüş %17’ye iner — üç ölçütün en iyi değerleri. Ama öncü süre 34,6’dan 69,7 adıma ve kurtarma süresi 45,4’ten 65,8 adıma çıkar. Nedeni hazırlığın sabit payıdır: yayın başına 4 adım sabit maliyet, parti birde değişiklik başına 5 adıma çıkar ve geliş aralığı 4 adımdır. Akış doyar. Parti küçültmenin kazancı sabit yayın maliyetinin bittiği yerde biter.

Kapı Eklemek

Kapı, üretimde çıkan hatayı gerçekten azaltan tek karardır: on iki kusurun sekizi yayından önce tutulur, dördü geçer ve değişiklik başına geri dönüş oranı %20’den %7’ye iner. Bu, ölçüt tanımından gelmeyen tek iyileşmedir.

Faturası ötekilerdedir. Her yayına 5 adım eklendiği için öncü süre 34,6’dan 36,8 adıma, dağıtım sıklığı 3,2’den 3,1’e gider. Kurtarma süresi de bozulur: 45,4’ten 54,8 adıma. Kapıdan geçen dört kusurun düzeltmesi de aynı kapıdan geçmek zorundadır. Yayına konan her kapı, düzeltmenin de kapısıdır.

Otomatik Geri Alma ve Masum Değişiklik

Otomatik geri alma kurtarma süresini 45,4 adımdan 7,0 adıma indirir — dört ölçütteki en büyük tek kazanç (−38,4). Bedeli dördüncü tablodadır: sekiz geri alma olayında altmış değişiklik-kez geri alınır ve bunun kırk sekizi masumdur. Masum değişikliklerin öncü süresi 64,5 adımdır; taban 34,6’dır. Toplam öncü süre 34,6’dan 50,6 adıma çıkar.

Bedel parti büyüklüğüne bağlıdır. Parti ikiye indirilip otomatik geri alma açıldığında geri alınan kırk sekiz masum değişiklik ona iner, masumların öncü süresi 35,8 adıma çekilir ve küme dengelenir: dağıtım 15,4, öncü süre 24,1, kurtarma 7,0. Geri alma biriminin büyüklüğü, geri almanın maliyetidir.

Üç kararı birden uygulamak bunu bozar. Parti iki, kapı ve otomatik geri alma birlikte, yayın başına geri dönüşü %11’e ve kurtarmayı 7,0 adıma indirir, ama öncü süreyi 109,3 adıma çıkarır: iki değişiklik için 4 artı 2 artı 5, yani 11 adım hazırlık, değişiklik başına 5,5 adım eder ve geliş aralığı 4 adımdır. Üç ayrı ölçütü iyileştiren üç kararın toplamı, kümenin en kötü öncü süresini verir.

Farkın Saklandığı Yer

Bu derste fark ölçütün tanımında saklıdır ve sayısı şudur: aynı yedi koşumda geri dönüş oranı yayın başına %11 ile %80 arasında oynar, değişiklik başına yalnız iki değer alır (%20 ve %7) ve üretimde çıkan hata yedi koşumun beşinde 12’dir. Bildirilmiş kısım oranın kendisidir; bildirilmemiş kısım paydadır. Yedi koşum ve dört ölçüt yirmi sekiz ölçüm verir: altı kararın dördünde en az bir ölçüt bozulur, ikisinde (parti 2 ve parti 2 artı otomatik) dördü birden iyileşir — ve o ikisinde de alandaki hata sayısı 12’de sabit kalır.

Sinyalin kime kaç adımda ulaştığı da bu kararlarla değişir: kusur otomatik geri almada 3 adımda tespit edilir ve 7 adımda kapanır, elle 12 adımda tespit edilir ve düzeltme yayınlanana kadar ortalama 45,4 adım sürer. M21/K05’in kalite göstergeleri bir değişikliğin içeriğini ölçüyordu; buradaki dört ölçüt teslimatın kendisini ölçer ve ikisi ancak kusur oranı üzerinden bağlanır.

Özet

• Dört ölçüt tek koşumdan okunur ve bağlıdır: yedi koşumun hiçbirinde bir karar tek başına kalmaz.
• Parti 8’den 2’ye inince dağıtım sıklığı 3,2 → 13,5, öncü süre 34,6 → 14,9, kurtarma 45,4 → 26,3 adım ve yayın başına geri dönüş %80 → %31 olur; üretimde çıkan hata 12’de kalır ve değişiklik başına oran %20’de sabittir.
• Partiyi 1’e indirmek dağıtım sıklığını 20,0’a çıkarır ama sabit yayın maliyeti akışı doyurur: öncü süre 69,7, kurtarma 65,8 adım.
• Kapı üretimdeki hatayı 12’den 4’e indiren tek karardır (geri dönüş %20 → %7) ve karşılığında öncü süreyi 36,8, kurtarma süresini 54,8 adıma çıkarır — düzeltme de aynı kapıdan geçer.
• Otomatik geri alma kurtarmayı 7,0 adıma indirir; parti 8’de 48 masum değişikliği geri alır ve onların öncü süresini 64,5 adıma taşır, parti 2’de aynı sayı 10’a ve 35,8 adıma iner.
• Üç kararın toplamı (parti 2, kapı, otomatik geri alma) yayın başına geri dönüşü %11’e indirirken öncü süreyi 109,3 adıma çıkarır.

Sonraki Adım

Kararların hepsi bir eşiğe göre verildi ama eşiğin kendisi hiç yazılmadı: ne kadar hata kabul edilebilir, kabul edilemez olduğunda ne durur. Sonraki ders bu eşiği bir sayıya bağlar — hedef erişilebilirlik verildiğinde dönemde kalan hata bütçesi dakikası, her olayın bütçeden düşürdüğü ve bütçe tükendiğinde dağıtım sıklığına konan kısıt ölçülür; bütçe kuralının bu dört ölçütte ölçülen etkisi sayılır.