---
title: 'Hat Aşamaları'
source: 'https://academia.sh/tr/kurslar/ci-cd/hat-asamalari'
course: 'Sürekli Tümleştirme ve Teslimat'
language: tr
updated: '2026-08-17T18:09:03+00:00'
license: 'CC BY-SA 4.0'
---

# Hat Aşamaları

Derleme, test, paketleme ve yayın kapılarının bilinen bir kusur kümesiyle ölçülmesi: her kapının tuttuğu, yalnız kendisinin tuttuğu, geçirdiği ve boşuna durdurduğu sayılır, eklediği süre çalıştırıcı dakikasıyla yazılır ve sekiz kapının her biri tek tek kaldırılarak kaldırılması daha iyi olan kapı bulunur.

Önceki ders hattın sonundaki elle onay kapısını ölçtü ve ondan önceki her şeyi tek bir kutu
olarak, "otomatik kapılar" diye andı. O kutunun içinde birden çok kapı vardır ve her birinin
kendi hesabı vardır. Bu ders kutuyu açar: sekiz kapılı bir hat kurulur, bilinen bir kusur
kümesi hattan geçirilir ve her kusurun hangi kapıda yakalandığı izlenir.

Sorulan şey her kapı için aynıdır. Kaç kusur tutuyor? Bunların kaçını **yalnız kendisi**
tutuyor, yani kapı kaldırılsa kaçı üretime kaçardı? Kaç kusuru geçiriyor, kaç temiz
değişikliği boşuna durduruyor? Ve kaç dakika ekliyor? Dördüncü soru üçüncüsünü değersiz
kılabilir: çok tutan bir kapı, tuttuklarının hepsini sonraki kapı da tutuyorsa hiçbir şey
katmıyordur. Dersin sonunda sekiz kapının her biri tek tek kaldırılır ve **kaldırılması daha
iyi olan kapı** sayıyla gösterilir.

## Hat ve Kusur Kümesi

Model, bölgesel ölçüm ağının hattıdır: sayaç okuma toplayıcı, doğrulayıcı, faturalama ve iş
emri servisleri; geliştirme, hazırlık ve üretim ortamları. **Ağ da hat da kurgudur; aşağıdaki
kusur kümesi bir modeldir.** Süreler model dakikasıdır, ölçümün koştuğu makineden bağımsızdır.

**HT13 — hat sekiz kapıdır ve sırası sabittir:** biçim çözümlemesi, derleme, birim sınamaları,
sözleşme sınamaları, tümleşim sınamaları, paketleme, hazırlık ortamında duman testi ve
üretimde yayın sağlığı penceresi. Erken kesme açıktır: kırmızı kapıdan sonraki kapılar
koşmaz.

**HT14 — bilinen kusur kümesi on dört sınıftır.** Her sınıfın yüz değişiklikte ortaya çıkma
sayısı, üretime kaçtığında ödettiği model dakikası ve **kapı başına yakalanma olasılığı**
yazılıdır. Tabloda yazılmayan kapı o sınıfı hiç görmez. Bir değişiklik birden çok kusur
taşıyabilir.

**HT15 — kırmızı bir kapıdan sonra yakalanan kusur düzeltilir ve değişiklik baştan koşar**,
en çok altı deneme. Düzeltmenin kendisi yeni kusur doğurmaz.

**HT16 — her kapının bir yanlış tutma olasılığı vardır**; yanlış tutulan değişiklik yeniden
koşar ve 35 model dakikası insan zamanı harcar.

**HT17 — toplam bedel üç kalemin toplamıdır:** çalıştırıcı dakikası, yanlış tutma sayısı × 35
ve üretime kaçan kusurların sınıf bedeli. Kapı kararı bu toplamla verilir.

**HT18 — 400 değişiklik koşturulur; bütün çekilişler önceden üretilir**, böylece bir kapı
kaldırıldığında kalan kapılar aynı sayıları görür ve karşılaştırma kapıyı yalıtır.

```js
// hat.mjs — sekiz kapili hat modeli ve bilinen kusur kumesi
const uretec = (tohum) => () => {
  tohum = (tohum * 1664525 + 1013904223) >>> 0;
  return tohum / 4294967296;
};

// HT13: kapi sirasi, kapi basina model dakikasi, kapi basina yanlis tutma olasiligi.
export const kapilar = [
  { ad: 'bicim', dk: 1, yanlis: 0.005 },
  { ad: 'derleme', dk: 4, yanlis: 0.004 },
  { ad: 'birim', dk: 3, yanlis: 0.012 },
  { ad: 'sozlesme', dk: 11, yanlis: 0.040 },
  { ad: 'tumlesim', dk: 14, yanlis: 0.030 },
  { ad: 'paketleme', dk: 6, yanlis: 0.008 },
  { ad: 'duman', dk: 9, yanlis: 0.045 },
  { ad: 'saglik', dk: 20, yanlis: 0.035 },
].map((k, gi) => ({ ...k, gi }));   // gi: kapinin tam hattaki sabit sirasi

// HT14: bilinen kusur kumesi. sayi = yuz degisiklikte ortaya cikma, bedel = uretime kacarsa
// model dakikasi, gor = kapi basina yakalama olasiligi (yazilmayan kapi gormez).
export const siniflar = [
  { ad: 'bicim ihlali', sayi: 14, bedel: 40, gor: { bicim: 1.0 } },
  { ad: 'tur uyusmazligi', sayi: 8, bedel: 300, gor: { derleme: 0.95, birim: 0.40 } },
  { ad: 'eksik bagimlilik', sayi: 5, bedel: 500, gor: { derleme: 0.80, paketleme: 0.90 } },
  { ad: 'sinir kosulu', sayi: 7, bedel: 900, gor: { birim: 0.85, tumlesim: 0.25 } },
  { ad: 'bos deger cozumleme', sayi: 6, bedel: 800, gor: { birim: 0.60, tumlesim: 0.35, duman: 0.40 } },
  { ad: 'alan adi degisikligi', sayi: 4, bedel: 1600, gor: { sozlesme: 0.90, tumlesim: 0.85 } },
  { ad: 'istek bicimi kaymasi', sayi: 3, bedel: 1400, gor: { sozlesme: 0.85, tumlesim: 0.75, duman: 0.35 } },
  { ad: 'sema uyusmazligi', sayi: 4, bedel: 1800, gor: { tumlesim: 0.80, duman: 0.50 } },
  { ad: 'goc sirasi', sayi: 2, bedel: 2600, gor: { tumlesim: 0.35, duman: 0.55, saglik: 0.40 } },
  { ad: 'yapilandirma eksigi', sayi: 5, bedel: 1200, gor: { paketleme: 0.45, duman: 0.80 } },
  { ad: 'paket butunlugu', sayi: 2, bedel: 1000, gor: { paketleme: 0.90 } },
  { ad: 'gecikme gerilemesi', sayi: 3, bedel: 1500, gor: { duman: 0.15, saglik: 0.70 } },
  { ad: 'bellek sizintisi', sayi: 2, bedel: 2300, gor: { saglik: 0.55 } },
  { ad: 'is kurali yanlisligi', sayi: 3, bedel: 2000, gor: { birim: 0.20, tumlesim: 0.15, duman: 0.10 } },
];

export const DEGISIKLIK = 400, DENEME = 6;   // HT15: en cok alti deneme
export const YANLIS_DK = 35;                 // HT16: yanlis tutulan degisikligin insan bedeli

// HT18: butun cekilisler onceden uretilir; kapi kaldirilinca ayni sayilar kullanilir.
export const akisUret = (tohum) => {
  const r = uretec(tohum);
  return Array.from({ length: DEGISIKLIK }, () => ({
    kusur: siniflar.filter((s) => r() < s.sayi / 100)
      .map((s) => ({ s, cek: Array.from({ length: DENEME * kapilar.length }, () => r()) })),
    yanlisCek: Array.from({ length: DENEME * kapilar.length }, () => r()),
  }));
};
```

## Kapı Başına Dört Sayı

Ölçüm iki kez koşar: önce tam hat, sonra sekiz kez birer kapı eksik. `marjinal` sütunu
doğrudan kaldırma denemesinden okunur — kapı çıkarıldığında üretime kaçan kusurun ne kadar
arttığı.

```js
// kapi.mjs — her kusurun hangi kapida yakalandigi, kapi basina uc sayi ve kaldirma denemesi
import { kapilar, siniflar, akisUret, DEGISIKLIK, DENEME, YANLIS_DK } from './hat.mjs';

const kosumBir = (dizilim, akis) => {
  const say = Object.fromEntries(dizilim.map((k) => [k.ad,
    { tuttu: 0, gecti: 0, yanlis: 0, dk: 0 }]));
  let kacan = 0, kacanBedel = 0, kosum = 0;
  for (const d of akis) {
    let kalan = d.kusur.slice();
    for (let deneme = 0; deneme < DENEME; deneme++) {
      kosum++;
      let durduran = null;
      for (const k of dizilim) {
        const i = deneme * kapilar.length + k.gi;   // cekilis kapinin sabit sirasina bagli
        say[k.ad].dk += k.dk;
        if (d.yanlisCek[i] < k.yanlis) {                       // HT16: yanlis tutma
          say[k.ad].yanlis++; durduran = { k, gercek: false }; break;
        }
        const goren = kalan.filter((x) => x.cek[i] < (x.s.gor[k.ad] ?? 0));
        say[k.ad].gecti += kalan.length - goren.length;
        if (goren.length > 0) {
          say[k.ad].tuttu += goren.length;
          kalan = kalan.filter((x) => !goren.includes(x));     // HT15: duzeltilip yeniden kosar
          durduran = { k, gercek: true }; break;
        }
      }
      if (durduran === null) break;                            // yesil: kalanlar uretime gider
    }
    kacan += kalan.length;
    kacanBedel += kalan.reduce((a, x) => a + x.s.bedel, 0);
  }
  const dk = dizilim.reduce((a, k) => a + say[k.ad].dk, 0);
  const yanlis = dizilim.reduce((a, k) => a + say[k.ad].yanlis, 0);
  return { say, kacan, kacanBedel, kosum, dk, yanlis,
    toplam: dk + yanlis * YANLIS_DK + kacanBedel };
};

const akis = akisUret(88123);
const tam = kosumBir(kapilar, akis);
const kusurToplam = akis.reduce((a, d) => a + d.kusur.length, 0);
const s = (x, w) => String(x).padStart(w);

console.log(`degisiklik ${DEGISIKLIK}, kusur ${kusurToplam}, kusur sinifi ${siniflar.length}, kapi ${kapilar.length}`);
console.log(`tam hat: kosum ${tam.kosum}, calistirici ${tam.dk} dk, yanlis tutma ${tam.yanlis}, `
  + `uretime kacan ${tam.kacan} kusur / ${tam.kacanBedel} dk, toplam ${tam.toplam} dk\n`);

console.log(`${'kapi'.padEnd(11)}${s('dk', 4)}${s('tuttu', 7)}${s('marjinal', 10)}${s('gecirdi', 9)}${s('yanlis', 8)}${s('ekledigi dk', 13)}`);
const kaldir = {};
for (const k of kapilar) {
  const y = kosumBir(kapilar.filter((x) => x.ad !== k.ad), akis);
  kaldir[k.ad] = y;
  console.log(`${k.ad.padEnd(11)}${s(k.dk, 4)}${s(tam.say[k.ad].tuttu, 7)}${s(y.kacan - tam.kacan, 10)}`
    + `${s(tam.say[k.ad].gecti, 9)}${s(tam.say[k.ad].yanlis, 8)}${s(tam.say[k.ad].dk, 13)}`);
}

console.log(`\n${'dizilim'.padEnd(18)}${s('calistirici dk', 15)}${s('yanlis', 8)}${s('kacan', 7)}${s('kacan dk', 10)}${s('toplam dk', 11)}${s('fark', 8)}`);
console.log(`${'tam hat'.padEnd(18)}${s(tam.dk, 15)}${s(tam.yanlis, 8)}${s(tam.kacan, 7)}${s(tam.kacanBedel, 10)}${s(tam.toplam, 11)}${s('-', 8)}`);
for (const k of kapilar) {
  const y = kaldir[k.ad];
  console.log(`${(k.ad + ' yok').padEnd(18)}${s(y.dk, 15)}${s(y.yanlis, 8)}${s(y.kacan, 7)}${s(y.kacanBedel, 10)}`
    + `${s(y.toplam, 11)}${s(y.toplam - tam.toplam, 8)}`);
}
const iyi = kapilar.filter((k) => kaldir[k.ad].toplam < tam.toplam);
console.log(`\nkaldirilmasi toplami dusuren kapi: ${iyi.length ? iyi.map((k) => k.ad).join(', ') : 'yok'}`);
console.log('tohum taramasi (kaldirilmasi toplami dusuren kapi):');
for (const tohum of [88123, 4402, 71905, 3311]) {
  const a = akisUret(tohum), t0 = kosumBir(kapilar, a);
  const d = kapilar.filter((k) => kosumBir(kapilar.filter((x) => x.ad !== k.ad), a).toplam < t0.toplam);
  console.log(`  ${tohum}: ${d.length ? d.map((k) => k.ad).join(', ') : 'yok'} (kacan ${t0.kacan})`);
}
```

```
degisiklik 400, kusur 256, kusur sinifi 14, kapi 8
tam hat: kosum 713, calistirici 34140 dk, yanlis tutma 89, uretime kacan 27 kusur / 39600 dk, toplam 76855 dk

kapi         dk  tuttu  marjinal  gecirdi  yanlis  ekledigi dk
bicim         1     51        51      284       7          713
derleme       4     46         8      213       3         2620
birim         3     42        27      150       7         1818
sozlesme     11     18         1      119      17         6138
tumlesim     14     25        14       85      15         7336
paketleme     6     19        13       63       1         2910
duman         9     17        15       40      28         4185
saglik       20     11        12       28      11         8420

dizilim            calistirici dk  yanlis  kacan  kacan dk  toplam dk    fark
tam hat                     34140      89     27     39600      76855       -
bicim yok                   33688      87     78     40440      77173     318
derleme yok                 32422      87     35     43700      79167    2312
birim yok                   32350      76     54     67500     102510   25655
sozlesme yok                28180      74     28     40800      71570   -5285
tumlesim yok                26571      75     41     62100      91296   14441
paketleme yok               30906      90     40     51100      85156    8301
duman yok                   28216      51     42     59800      89801   12946
saglik yok                  24520      76     39     60400      87580   10725

kaldirilmasi toplami dusuren kapi: sozlesme
tohum taramasi (kaldirilmasi toplami dusuren kapi):
  88123: sozlesme (kacan 27)
  4402: sozlesme (kacan 16)
  71905: bicim, sozlesme (kacan 27)
  3311: yok (kacan 25)
```

## Tutmak ile Yalnız Tutmak

`tuttu` ve `marjinal` sütunları birbirini takip etmez. Derleme kapısı 46 kusur tutar, ama
kaldırıldığında üretime kaçan yalnız 8 artar: tuttuklarının çoğunu birim ve paketleme
kapıları da görüyordur. Sözleşme kapısı 18 tutar, marjinali 1'dir. Buna karşılık biçim
kapısı 51 tutar ve 51'i marjinaldir — biçim ihlallerini hattaki hiçbir başka kapı görmez.

Sıralama üçüncü bir sayıyla tersine döner: marjinal kusurun **bedeli**. Biçim ihlalinin
sınıf bedeli 40 dakikadır, bellek sızıntısınınki 2 300, göç sırasınınki 2 600. Biçim kapısı
kaldırıldığında kaçış bedeli 840 dakika artar; sağlık kapısı kaldırıldığında 20 800 dakika,
yani on iki kusur için kusur başına 1 733 dakika. Bu yüzden **en çok tutan kapı en değerli
kapı değildir**: biçim kapısının kaldırılması toplamı 318 dakika artırır, sağlık kapısınınki
10 725. Kapının değeri tuttuğu kusur sayısında değil, yalnız kendisinin tuttuğu kusurların
bedelindedir.

`gecirdi` sütunu sıranın doğal sonucudur ve tek başına bir suçlama değildir. Biçim kapısı
284 kusur geçirir, çünkü ilk sırada durur ve hattaki her kusuru görür. Sağlık kapısı 28
geçirir, çünkü ona ulaşan kusur zaten azdır. Bu sütun ancak kapının **görmesi beklenen**
sınıfla birlikte okunduğunda anlam taşır.

`ekledigi dk` sütunu kapı süresinin kaç koşumla çarpıldığına bağlıdır ve erken kesme bu
çarpanı aşağı çeker. Sütun kapı süresine bölündüğünde kapı başına koşum sayısı çıkar:
biçim 713, derleme 655, birim 606, sözleşme 558, tümleşim 524, paketleme 485, duman 465,
sağlık 421. Hat boyunca ilerledikçe koşum sayısı düşer, çünkü önceki kapılardan birinde
duran değişiklik sonrakilere hiç ulaşmaz. Sağlık kapısı koşum başına en pahalı kapıdır
(20 dakika) ama en az koşar; hattın toplam çalıştırıcı yükünün dörtte biri yine de ona aittir.

Yanlış tutma sütunu bağımsız bir eksendir. Duman testi kapısı 28 kez temiz bir değişikliği
boşuna durdurur, hattaki en yüksek sayıdır; buna rağmen marjinali 15 kusurdur ve kaldırılması
toplamı 12 946 dakika artırır. Kararsızlığı yüksek bir kapı, marjinali yeterse yerinde
kalır — çözüm onu kaldırmak değil, kararsızlığını düşürmektir.

## Kaldırılması Daha İyi Olan Kapı

İkinci tablo sekiz kaldırma denemesini toplam bedelle sıralar. Yedi kapı için `fark` sütunu
artıdır: kaldırma pahalıya gelir. Birim kapısı en pahalı kayıptır, 25 655 dakika — çünkü
sınır koşulu ve boş değer çözümlemesi sınıflarını asıl gören kapıdır ve 3 dakikaya mal olur.
Kapı başına en iyi takas hattın başındadır.

Bir kapı ayrılır. **Sözleşme kapısı kaldırıldığında toplam 5 285 dakika düşer.** Kapının
kendi hesabı bunu açıklar: 18 kusur tutar, ama bunların 17'sini tümleşim kapısı zaten
yakalıyordur; marjinali 1 kusurdur. Karşılığında 6 138 çalıştırıcı dakikası ekler ve 17 temiz
değişikliği boşuna durdurur. Kaldırıldığında üretime kaçan 27'den 28'e çıkar — **bir kusur
karşılığında 5 285 dakika**. Bu kapı yanlış kurulmuş değildir; hattaki yeri yanlıştır. Alan
adı değişikliğini 0,90, tümleşim ise 0,85 olasılıkla görüyorsa, ikisini birlikte tutmanın
kazancı ölçülebilir biçimde küçüktür.

Tohum taraması sonucun ne kadar sağlam olduğunu gösterir: dört tohumun üçünde sözleşme
kapısı çıkar, birinde hiçbir kapı çıkmaz, birinde biçim kapısı da listeye girer. Yani karar
"sözleşme sınaması gereksizdir" değildir; **bu kusur kümesinde, bu hat sırasında ve bu
kapı süreleriyle** sözleşme kapısının marjinali maliyetinin altındadır. Kusur kümesi
değişirse — örneğin servisler arası sözleşmeler daha sık kırılırsa — aynı hesap kapıyı geri
getirir. Kararı taşıyan şey kapının adı değil, tablodaki dört sayısıdır.

## Özet

- Sekiz kapılı hat 400 değişiklik ve 256 kusurla koşturuldu: 713 koşum, 34 140 çalıştırıcı
  dakikası, 89 yanlış tutma, üretime kaçan 27 kusur ve 39 600 dakikalık kaçış bedeli.
- Tuttuğu ile yalnız kendisinin tuttuğu ayrıdır: derleme 46 tutar, marjinali 8; sözleşme 18
  tutar, marjinali 1; biçim 51 tutar ve 51'i marjinaldir.
- En çok tutan kapı en değerli kapı değildir: biçim kapısının kaldırılması toplamı 318,
  sağlık kapısının kaldırılması 10 725 dakika artırır.
- Yanlış tutma tek başına kapıyı düşürmez: duman testi kapısı 28 temiz değişikliği boşuna
  durdurur, ama marjinali 15 kusur olduğu için yerinde kalır.
- Sözleşme kapısının kaldırılması toplamı 5 285 dakika düşürdü; bir kusur karşılığında 6 138
  çalıştırıcı dakikası ve 17 yanlış tutma ödenmekteydi.
- Sonuç kapının adına değil dört sayısına bağlıdır: dört tohumun üçü aynı kapıyı, biri
  hiçbirini gösterdi.

## Sonraki Adım

Hat 713 koşum boyunca bir şey üretti ve bu ders o şeyi hiç saymadı: paketleme kapısının
çıkardığı **yapı çıktısı**. Yeşil biten her koşumun sonunda ortada bir paket vardır ve o
paket üretime giden şeydir. İki soru cevapsızdır. Bu paketin kimliği neye bağlıdır — hangi
işlemeye, hangi dala, kaçıncı koşuma — ve o kimlikten geriye, paketi üreten kaynağa
dönülebilir mi? İkincisi, aynı paket üretimde bir arıza çıkardığında bir önceki sürüme
dönmek için o sürümün hâlâ duruyor olması gerekir; saklama kuralı sıkılaştıkça geri
alınabilir sürüm penceresi daralır, gevşedikçe depo büyür. Sonraki ders bu iki sayıyı
birlikte ölçer.
