Çalışma Yordamları

Nöbet düzeni “kim” ve “ne zaman” sorularını yanıtladı, sınıflandırma “hangi düzeyde” sorusunu ekledi. Doğru kişi doğru anda uyandığında elinde tek bir soru kalır: hangi adımla.

Çalışma yordamı, yinelenen bir müdahalenin adım adım yazılmış hâlidir. M20/K05 İşletim Devri dersi yazılmamış yordamın devir üzerindeki bedelini saydı; burada yordam yazılıdır ve ölçülen yordamın kendisidir: kaç adım, kaç karar noktası, kaçı makineye verilebilir, ve yazıldıktan bir süre sonra kaçı hâlâ doğru.

Yordam Bir Belge Değil, Bir Adım Dizisi

Örnek yine kursun kurgu bölgesel ölçüm ağıdır: su sayacı okuma toplayıcı, doğrulayıcı, faturalama ve iş emri servisleri. Ağ da yordamlar da kurgudur; gerçek bir yordam metni ya da koşum geçmişi yoktur.

OY13: Dört yinelenen müdahale için birer yordam yazılır; adım türü gözle, doğrula, müdahale ya da karardır ve karar noktası hiçbir koşulda otomatikleştirilemez. OY14: Her adım bir dayanağa bağlıdır — gösterge adı, seri adı, eşik değeri, dosya yolu, bayrak adı, kuyruk adı, kimlik alanı, sürüm etiketi. Dayanak değişirse o dayanağa bağlı her adım geçersizdir. OY15: Yordamsız koşumda adımı bulmak süreyi 2,8 katına çıkarır ve adım başına hata olasılığı 0,34’tür; yazılı yordamla 0,08. Hatalı adımın düzeltilmesi 9 dakikadır. OY16: Karar noktasında yanlış dal seçme olasılığı 0,18, bedeli 12 dakikadır. OY17: Geçersiz adım ilk koşumda 16 dakika gecikme üretir; sonraki koşumlarda bilindiği için 3 dakikada dolanılır, ama her iki durumda da hata adımı sayılır. OY18: Her dönemde iki dayanak değişir; aynı yordam kümesi 40 olayda koşulur.

// yordam/yordam.mjs — kurgu bolgesel olcum aginin calisma yordami modeli (model): gercek bir
// yordam metni, olay kaydi ya da kosum gecmisi yok. Uretec kendi yazildi, tohum gorunur.

export const SERVIS = ["okuma-toplayici", "dogrulayici", "faturalama", "is-emri"];
export const TUR = ["gozle", "dogrula", "mudahale", "karar"];
// Adimin bagli oldugu sistem gercegi. Bu dayanak degisirse adim gecersiz olur.
export const DAYANAK = ["gosterge-adi", "seri-adi", "esik-degeri", "dosya-yolu", "bayrak-adi",
  "kuyruk-adi", "kimlik-alani", "surum-etiketi"];

export const KESIF = 2.8;        // yordamsiz kosumda adimi bulmanin sure carpani
export const HATA = { yok: 0.34, var: 0.08 };   // adim basina hata olasiligi
export const DUZELT = 9;         // hatali adimin duzeltilmesi (dakika)
export const YANLIS_DAL = 0.18;  // karar noktasinda yanlis dal secme olasiligi
export const DAL_CEZA = 12;      // yanlis dalin bedeli (dakika)
export const ILK_CEZA = 16;      // gecersiz adim ilk kosumda: denenir, tutmaz, elle bulunur
export const SONRAKI_CEZA = 3;   // ayni adim sonraki kosumlarda: bilinir, dolanilir
export const DEGISIM = 2;        // her donemde sistemde degisen dayanak sayisi

export function uretec(tohum) {
  let x = tohum >>> 0 || 1;
  return () => { x ^= x << 13; x >>>= 0; x ^= x >>> 17; x ^= x << 5; x >>>= 0;
    return x / 4294967296; };
}
const sec = (r, a) => a[Math.floor(r() * a.length)];

// Her servis icin bir yordam: 6-10 adim. Otomatiklestirilebilirlik adimin turune baglidir;
// karar noktasi hicbir kosulda otomatiklestirilemez.
export function yordamlar(tohum) {
  const r = uretec(tohum);
  return SERVIS.map((servis) => {
    const adet = 6 + Math.floor(r() * 5);
    const adim = [];
    for (let i = 0; i < adet; i++) {
      const u = r();
      const tur = u < 0.22 ? "gozle" : u < 0.52 ? "dogrula" : u < 0.82 ? "mudahale" : "karar";
      const otomatik = tur === "karar" ? false
        : r() < (tur === "mudahale" ? 0.40 : 0.75);
      adim.push({ tur, otomatik, dakika: 2 + Math.floor(r() * 11),
        dayanak: sec(r, DAYANAK) });
    }
    return { servis, adim };
  });
}

// mod: "yok" yordamsiz, "var" yazili yordamla, "oto" otomatiklestirilebilir adimlar makinede.
// gecersiz: gecersiz dayanaklar. gorulen: daha once bir kosumda ortaya cikmis gecersiz adimlar;
// gecersiz adim yalnizca ILK kosumda tam bedelini uretir, sonrakilerde dolanilir.
export function kos(y, mod, r, gecersiz = new Set(), gorulen = new Set()) {
  let dakika = 0, hataAdim = 0, ilkGecikme = 0, atlanan = 0;
  for (const [i, a] of y.adim.entries()) {
    const oto = mod === "oto" && a.otomatik;
    if (oto) { atlanan++; } else { dakika += a.dakika * (mod === "yok" ? KESIF : 1); }
    if (gecersiz.has(a.dayanak)) {      // yordam sistemin gerisinde kaldi
      const anahtar = `${y.servis}:${i}`;
      if (gorulen.has(anahtar)) { dakika += SONRAKI_CEZA; hataAdim++; continue; }
      gorulen.add(anahtar);
      dakika += ILK_CEZA; ilkGecikme += ILK_CEZA; hataAdim++;
      continue;
    }
    if (oto) continue;                  // makinede kosan adim yanilmaz
    if (r() < HATA[mod === "yok" ? "yok" : "var"]) { dakika += DUZELT; hataAdim++; }
    if (a.tur === "karar" && r() < YANLIS_DAL) { dakika += DAL_CEZA; hataAdim++; }
  }
  return { dakika, hataAdim, ilkGecikme, atlanan };
}

// Eskime: her donemde DEGISIM dayanak degisir. Degisen dayanaga bagli her adim gecersizdir.
export function eskit(tohum, donem) {
  const r = uretec(tohum), g = new Set();
  for (let d = 0; d < donem; d++)
    for (let i = 0; i < DEGISIM; i++) g.add(sec(r, DAYANAK));
  return g;
}

// yordam/olc.mjs — yordamin kendisi: adim, karar noktasi, otomatiklestirme ve eskime.
import { yordamlar, kos, eskit, uretec, TUR, DAYANAK, DEGISIM } from "./yordam.mjs";

const TOHUM = 20261107;
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 s1 = (x) => x.toFixed(1);
const say = (a, f) => a.filter(f).length;

const Y = yordamlar(TOHUM);
const tumAdim = Y.flatMap((y) => y.adim);
const KOSUM = 40;                      // ayni yordam kumesi 40 olayda kosulur

// Ayni olay kumesini bir bicimde kosar. Her kosum ayni tohumdan baslar, boylece bicimler
// arasindaki fark bicimden gelir, cekilislerden degil.
const dene = (mod, gecersiz) => {
  const r = uretec(TOHUM + 7), gorulen = new Set(), kayit = [];
  for (let i = 0; i < KOSUM; i++) kayit.push(kos(Y[i % Y.length], mod, r, gecersiz, gorulen));
  const t = (f) => kayit.reduce((a, x) => a + f(x), 0);
  return { dakika: t((x) => x.dakika) / KOSUM, hata: t((x) => x.hataAdim),
    ilk: t((x) => x.ilkGecikme), atlanan: t((x) => x.atlanan) };
};

const E = [-16, 7, 12, 15, 10, 11];
console.log(`tohum ${TOHUM}: ${Y.length} yordam, ${tumAdim.length} adim, ${KOSUM} kosum`);
console.log("\n1. yordam envanteri");
yaz(E, "yordam", "adim", "karar nok.", "otomatik adim", "dakika", "dayanak");
for (const y of Y)
  yaz(E, y.servis, y.adim.length, say(y.adim, (a) => a.tur === "karar"),
    say(y.adim, (a) => a.otomatik), y.adim.reduce((a, x) => a + x.dakika, 0),
    new Set(y.adim.map((a) => a.dayanak)).size);
yaz(E, "toplam", tumAdim.length, say(tumAdim, (a) => a.tur === "karar"),
  say(tumAdim, (a) => a.otomatik), tumAdim.reduce((a, x) => a + x.dakika, 0),
  new Set(tumAdim.map((a) => a.dayanak)).size);
console.log("adim turu: " + TUR.map((t) => `${t} ${say(tumAdim, (a) => a.tur === t)}`).join(", "));

const g2 = eskit(TOHUM + 3, 2);        // iki donem eskimis yordam
const M = [-22, 17, 14, 16, 16];
console.log("\n2. ayni 40 olay uc kosum biciminde (taze yordam / iki donem eskimis)");
yaz(M, "bicim", "ort kapanis dk", "hata adimi", "makinede adim", "yordamsiza gore");
const taze = {}, eski = {};
for (const [ad, b] of [["yordamsiz", "yok"], ["yazili yordamla", "var"],
  ["otomatiklestirilmis", "oto"]]) {
  taze[b] = dene(b, new Set());
  eski[b] = b === "yok" ? taze[b] : dene(b, g2);
  const pay = (x) => `%${((x.dakika / taze.yok.dakika) * 100).toFixed(0)}`;
  yaz(M, ad, `${s1(taze[b].dakika)} / ${s1(eski[b].dakika)}`,
    `${taze[b].hata} / ${eski[b].hata}`, `${taze[b].atlanan} / ${eski[b].atlanan}`,
    `${pay(taze[b])} / ${pay(eski[b])}`);
}

const D = [-8, 15, 15, 19, 16, 13];
console.log(`\n3. yordamin eskimesi (yazili yordam, donem basina ${DEGISIM} degisim)`);
yaz(D, "donem", "gecersiz day.", "gecersiz adim", "ilk kosum gecikme", "ort kapanis dk",
  "hata adimi");
for (const donem of [0, 1, 2, 3, 4]) {
  const g = eskit(TOHUM + 3, donem);
  const r = dene("var", g);
  yaz(D, donem, `${g.size}/${DAYANAK.length}`,
    `${say(tumAdim, (a) => g.has(a.dayanak))}/${tumAdim.length}`,
    `${r.ilk} dk`, s1(r.dakika), r.hata);
}

const Q = [-38, 20, 8];
console.log("\n4. yordamin yanitladigi soru kumesi");
yaz(Q, "soru", "veri", "yanit");
const SORU = [
  ["bu olay daha once oldu mu", "yordam dizini", true],
  ["hangi adimla kapanir", "yordam metni", true],
  ["kac adim, kac karar noktasi", "yordam metni", true],
  ["hangi adim makineye verilebilir", "adim turu", true],
  ["yordam en son ne zaman kosuldu", "kosum kaydi", true],
  ["bu adim hala gecerli mi", "-", false],
  ["karar noktasinda dogru dal hangisi", "-", false],
  ["kac adim artik gecersiz", "-", false]];
for (const [q, d, y] of SORU) yaz(Q, q, d, y ? "evet" : "hayir");
console.log(`${SORU.length} sorudan ${say(SORU, (x) => x[2])} tanesi yordamdan yanitlanir, ` +
  `${say(SORU, (x) => !x[2])} tanesi yordam kosulmadan yanitlanamaz`);

tohum 20261107: 4 yordam, 33 adim, 40 kosum

1. yordam envanteri
yordam             adim  karar nok.  otomatik adim    dakika    dayanak
okuma-toplayici       6           2              2        47          3
dogrulayici           9           1              5        64          5
faturalama           10           0              5        86          6
is-emri               8           3              2        56          5
toplam               33           6             14       253          8
adim turu: gozle 7, dogrula 8, mudahale 12, karar 6

2. ayni 40 olay uc kosum biciminde (taze yordam / iki donem eskimis)
bicim                    ort kapanis dk    hata adimi   makinede adim yordamsiza gore
yordamsiz                 203.1 / 203.1     113 / 113           0 / 0     %100 / %100
yazili yordamla             72.8 / 83.3      40 / 161           0 / 0       %36 / %41
otomatiklestirilmis         37.5 / 49.8      25 / 154       140 / 140       %18 / %24

3. yordamin eskimesi (yazili yordam, donem basina 2 degisim)
donem     gecersiz day.  gecersiz adim  ilk kosum gecikme  ort kapanis dk   hata adimi
0                   0/8           0/33               0 dk            72.8           40
1                   2/8          10/33             160 dk            80.6          126
2                   3/8          14/33             224 dk            83.3          161
3                   5/8          20/33             320 dk            88.1          214
4                   6/8          24/33             384 dk            91.6          251

4. yordamin yanitladigi soru kumesi
soru                                                  veri   yanit
bu olay daha once oldu mu                    yordam dizini    evet
hangi adimla kapanir                          yordam metni    evet
kac adim, kac karar noktasi                   yordam metni    evet
hangi adim makineye verilebilir                  adim turu    evet
yordam en son ne zaman kosuldu                 kosum kaydi    evet
bu adim hala gecerli mi                                  -   hayir
karar noktasinda dogru dal hangisi                       -   hayir
kac adim artik gecersiz                                  -   hayir
8 sorudan 5 tanesi yordamdan yanitlanir, 3 tanesi yordam kosulmadan yanitlanamaz

Sayılar ölçüm sınıfındadır; girdileri OY13–OY18 varsayımlarıdır. Dört yordam 33 adım, 6 karar noktası ve 253 dakikalık nominal süre taşır. Envanter tek başına iki şeyi söyler. faturalama en uzun yordamdır (10 adım, 86 dakika) ama hiç karar noktası yoktur — baştan sona düz koşar. is-emri yalnız 8 adımdır, ama 3 karar noktası taşır: kısa yordam kolay yordam değildir.

Yordamsız, Yordamla, Makineyle

İkinci tablonun sol yarısı aynı 40 olayı üç biçimde kapatır. Yordamsız koşumda ortalama kapanış 203,1 dakika ve 113 hata adımıdır; adımı bulmak süreyi katlar ve her bulunan adım yanılabilir. Yazılı yordam kapanışı 72,8 dakikaya, yani yordamsızın %36’sına indirir ve hata adımını 113’ten 40’a düşürür. Kazanç iki kaynaklıdır ve ayrılabilir: keşif çarpanının kalkması süreyi, hata olasılığının 0,34’ten 0,08’e inmesi yanılmayı azaltır.

Otomatikleştirme üçüncü sırayı alır. 33 adımın 14’ü makineye verilebilir (%42) ve 40 koşumda toplam 140 adım makinede koşar; kapanış 37,5 dakikaya, yordamsızın %18’ine iner, hata adımı 25’e düşer. Bu tavan tesadüf değildir: kalan 19 adımın 6’sı karar noktasıdır ve varsayım gereği otomatikleştirilemez. Yordamın otomatikleştirilemeyen çekirdeği, sayılabilen bir büyüklüktür — burada altı karar.

Yordamın Eskimesi

Üçüncü tablo yordamı olduğu yerde bırakıp sistemi değiştirir. Bir dönemde iki dayanak değişir ve 33 adımın 10’u geçersiz olur; dört dönem sonra sekiz dayanağın altısı değişmiş, geçersiz adım 24’e çıkmıştır. Geçersiz adımın ilk koşumdaki bedeli doğrudan okunur: birinci dönemde 160, dördüncü dönemde 384 dakika.

Asıl bulgu iki sütunun farklı hızda bozulmasıdır. Ortalama kapanış 72,8’den 91,6 dakikaya çıkar — dört dönemde yalnız %26. Hata adımı ise 40’tan 251’e, altı katına çıkar. Nedeni varsayımın içindedir: geçersiz adım ilk koşumda 16 dakika yer, sonraki koşumlarda 3 dakikada dolanılır, ama her seferinde bir hata adımı olarak kalır. Eskiyen yordam yavaşlamaz, güvenilmez hâle gelir; saati izleyen bir ölçüm bunu göremez.

İkinci tablonun sağ yarısı bunu keskinleştirir. İki dönem eskimiş yordam kapanışı yalnız 72,8’den 83,3 dakikaya taşır ve hâlâ yordamsızdan çok hızlıdır (%41’e karşı %100). Ama hata adımı 161’dir — yordamsız koşumun 113 hata adımından fazla. Eskimiş yordam koşanı hızlandırırken yanlış adıma daha çok kez sokar.

Otomatikleştirme bu bozulmayı durdurmaz. Makineye verilen adım da aynı dayanağa bağlıdır: iki dönem sonra otomatikleştirilmiş biçimin hata adımı 25’ten 154’e çıkar, yani yazılı yordamın 161’iyle neredeyse aynı yerdedir. Kapanış 37,5’ten 49,8 dakikaya çıkar. Otomatikleştirme adımı hızlandırır, adımın dayanağını doğrulamaz.

Yordamın Bilmediği

Dördüncü tablo sekiz sorunun beşinin yordamdan yanıtlandığını gösterir: olayın daha önce olup olmadığı, hangi adımla kapanacağı, kaç adım ve kaç karar noktası olduğu, hangi adımın makineye verilebileceği, yordamın en son ne zaman koşulduğu. Yanıtsız üçü tek bir eksikliğe indirgenir — yordam kendi geçerliliğini bilmez. “Bu adım hâlâ geçerli mi”, “karar noktasında doğru dal hangisi” ve “kaç adım artık geçersiz” soruları ancak yordam koşulduğunda, yani bir olayın ortasında yanıtlanır. Üçüncü tablodaki 160 ile 384 dakika arasındaki gecikme, bu üç sorunun faturasıdır.

Özet

• Dört yordam 33 adım, 6 karar noktası ve 253 dakikalık nominal süre taşır; adımların 14’ü (%42) makineye verilebilir. En uzun yordamda hiç karar noktası yok, 8 adımlık yordamda üç tane var.
• Aynı 40 olay yordamsız 203,1 dakikada ve 113 hata adımıyla, yazılı yordamla 72,8 dakikada (%36) ve 40 hata adımıyla kapanır.
• Otomatikleştirme kapanışı 37,5 dakikaya (%18) ve hata adımını 25’e indirir; tavanı belirleyen şey otomatikleştirilemeyen 6 karar noktasıdır.
• Bir dönemde iki dayanak değişince 33 adımın 10’u, dört dönem sonra 24’ü geçersiz olur; geçersiz adımların ilk koşumda ürettiği gecikme 160’tan 384 dakikaya çıkar.
• Eskime süreyi ve güveni farklı hızda bozar: kapanış 72,8’den 91,6 dakikaya (%26) çıkarken hata adımı 40’tan 251’e (altı katı) çıkar.
• İki dönem eskimiş yordam yordamsızdan hâlâ iki kattan fazla hızlıdır (83,3’e karşı 203,1 dakika) ama yordamsızdan çok yanılır (161’e karşı 113 hata adımı); otomatikleştirme bunu değiştirmez (154).

Sonraki Adım

Yordam bir olayın nasıl kapanacağını yazar, neden açıldığını yazmaz. Üçüncü tablodaki geçersiz adımlar da kendiliğinden düzelmez; birinin onları görüp yordamı güncellemesi gerekir. Sonraki ders olay kapandıktan sonrasına bakar: olayın suçsuz biçimde incelenmesi, incelemeden çıkan eylem maddelerinin izlenmesi ve kapanmayan maddenin aynı olayı yeniden üretmesi.