---
title: 'İşletim Devri'
source: 'https://academia.sh/tr/kurslar/surec-ve-ekip/isletim-devri'
course: 'Süreç, Ekip ve Teslimat'
language: tr
updated: '2026-08-17T18:10:35+00:00'
license: 'CC BY-SA 4.0'
---

# İşletim Devri

Geliştirme ile işletim arasındaki sorumluluk sözleşmesi: yirmi sekiz sorumluluk kaleminin yirmisinin devredilmesi ve sekizinin bilgi, araç ya da yordam yokluğunda geliştirmede kalması, aynı on dört olayın paylaşımlı nöbette 3,8 tam devirde 5,0 turda kapanması, buna karşılık geliştirme akışından çıkan turun 37'den 54'e ve yeniden işin 9'dan 20 tura çıkması, üç yazılmamış yordam yazıldığında geri dönen olayın 8'den 5'e ve akış sonunun 94'ten 84. tura inmesi.

Önceki ders kapsam değişikliğini denetime bağladı ve bedelini saydı, ama sayacı kalemin teslim
edildiği anda durdurdu. Teslim modelde son adımın bitmesidir; alanda servisin gece de ayakta
durması gereken ilk gündür.

**İşletim devri**, bir servisin işletme sorumluluğunun yazan ekipten işleten ekibe geçmesidir ve
tek parça değildir, kalem kalem devredilir. Bu ders devri bir **sözleşme** olarak modeller: hangi
kalem devredildi, devredilemeyen neden devredilemedi ve faturası nereye çıkıyor.

## Devir Sözleşmesi Kalem Kalem

Örnek, kursun kurgu **bölgesel kütüphane ağı** ile onu yazan üç ekiptir; ağ da ekipler de
kurgudur. **ET28:** yedi servis üç yazan ekibe, bir de işletim ekibine dağılmıştır; `ortak-kayit`
servisine üç ekip birden dokunur. Her ekibin önünde altı kalem, kalem başına altı tur iş vardır.
**ET29:** gün on turdur; ilk altı turu mesai, son dördü gecedir ve kalem yalnız mesaide ilerler.
**ET30:** sözleşme dört sorumluluk kalemidir — koşum, ilk yanıt, yeniden başlatma, yapılandırma
değişikliği; devredilememenin nedeni **bilgi**, **araç** ya da **yordam** eksikliğidir. **ET31:**
ağır olay gece de karşılanır, hafif olay sabaha kalır. **ET32:** kesilen ekip yanıt süresi artı iki
tur toparlanma boyunca akıştan çıkar, kesinti kalemin ortasına düşerse en çok iki tur yeniden iş
yazılır, gece uyandırılan ekip ertesi sabah iki tur kaybeder. **ET33:** devredilmiş sorumluluğu
işletim ekibi iki turda kapatır; geri dönen olayın çözümü, bağlam ikinci elden kurulduğu için,
yazan ekibe üç tur tutar (paylaşımlı nöbette iki).

Sözleşme ile iki nöbet biçimi süreç içi bir **modeldir**; gerçek bir nöbet çizelgesi ya da olay
kaydı yoktur.

```js
// devir/nobet.mjs — kurgu kutuphane aginin isletim devri ve nobet modeli (model): gercek bir
// nobet cizelgesi ya da olay kaydi yok, turlar veri yapisidir. Rastgelelik yok.

export const GUN = 10, MESAI = 6;          // her gun 10 tur: ilk 6 tur mesai, son 4 tur gece
export const ILK = 1, UYAN = 2, AKTAR = 1, COZ_DEVIR = 2, COZ_YAZAN = 3, COZ_ICERI = 2;
export const TOPARLANMA = 2, UYKU = 2, YENIDEN_TAVAN = 2;
export const KALEM_IS = [6, 6, 6, 6, 6, 6];   // her yazan ekibin onundeki alti kalem
export const EKIPLER = ["E1", "E2", "E3"];

export const gece = (t) => t % GUN >= MESAI;
export const sabah = (t) => (Math.floor(t / GUN) + 1) * GUN;

const cizelge = (s, f) => s.trim().split("\n").map((r) => f(r.trim().split(/\s+/)));

// Devir sozlesmesi: servis, sahip ekip, dokunan ekip sayisi, dort sorumluluk. "+" devredildi;
// digerleri devredilemedi ve nedenini yazar (bilgi, arac, yordam).
export const SOZLESME = cizelge(`
  odunc           E2  1  +  +  +       bilgi
  ucret           E2  1  +  +  +       +
  sube-onyuz      E1  1  +  +  +       +
  uyelik-kapisi   E1  1  +  +  arac    arac
  katalog-kapisi  E3  1  +  +  +       yordam
  bildirim        E3  1  +  +  yordam  yordam
  ortak-kayit     E3  3  +  +  bilgi   bilgi`,
([servis, ekip, dokunan, ...h]) => ({ servis, ekip, dokunan: +dokunan,
  hak: { kosum: h[0], "ilk-yanit": h[1], "yeniden-baslatma": h[2], yapilandirma: h[3] } }));

// Olay: geldigi tur, servis, kapanmasi icin gereken sorumluluk, agirlik.
export const OLAY = cizelge(`
   3  odunc           yapilandirma      agir
   7  ucret           yeniden-baslatma  agir
  12  ortak-kayit     yapilandirma      agir
  16  bildirim        yeniden-baslatma  agir
  18  sube-onyuz      yapilandirma      agir
  23  uyelik-kapisi   yeniden-baslatma  agir
  27  katalog-kapisi  yapilandirma      hafif
  31  odunc           yeniden-baslatma  agir
  36  ortak-kayit     yeniden-baslatma  agir
  39  bildirim        yapilandirma      agir
  44  ucret           yapilandirma      agir
  47  uyelik-kapisi   yapilandirma      hafif
  50  katalog-kapisi  yeniden-baslatma  agir
  52  sube-onyuz      yeniden-baslatma  hafif`,
([tur, servis, cozum, a]) => ({ tur: +tur, servis, cozum, agir: a === "agir" }));

// bicim: "tam" isletim ekibi her olayi karsilar, "paylasimli" yazan ekip nobettedir.
// kapat: bu nedenle devredilememis kalemler kapatilmis sayilir (karsit koseum).
export function kos(bicim, kapat = null) {
  const S = Object.fromEntries(SOZLESME.map((s) => [s.servis, s]));
  const ekip = Object.fromEntries(EKIPLER.map((e) =>
    [e, { mesgul: 0, i: 0, yapilan: 0, cikan: 0, yenidenIs: 0, bitis: null }]));
  const plan = {}, kayit = [];
  const ekle = (e, t, sure) => ((plan[t] ??= []).push([e, sure]));
  const acik = (s, c) => s.hak[c] === "+" || s.hak[c] === kapat;

  const isle = (o, t) => {
    const s = S[o.servis];
    if (bicim === "tam" && acik(s, o.cozum))          // yazili yordamla isletim ekibi kapatir
      return { s, ilk: ILK, kapanis: ILK + COZ_DEVIR, eld: 1, geri: false, uyandi: false,
        kesinti: 0, neden: "-" };
    const geri = bicim === "tam";
    const eld = (geri ? 2 : 1) + (s.dokunan > 1 ? 1 : 0);
    const ak = AKTAR * (eld - 1), coz = geri ? COZ_YAZAN : COZ_ICERI;
    const ilkYanit = geri ? ILK : gece(t) ? (o.agir ? UYAN : sabah(t) - t) : ILK;
    const neden = geri ? s.hak[o.cozum] : "-";
    const ort = { s, ilk: ilkYanit, eld, geri, neden };
    if (!gece(t)) {
      const kesinti = (geri ? 0 : ILK) + ak + coz + TOPARLANMA;
      ekle(s.ekip, t, kesinti);
      return { ...ort, kapanis: ilkYanit + ak + coz, uyandi: false, kesinti };
    }
    if (o.agir) {                                     // gece uyandirma: bedeli ertesi sabah
      ekle(s.ekip, sabah(t), UYKU);
      return { ...ort, kapanis: (geri ? ILK + UYAN : UYAN) + ak + coz, uyandi: true,
        kesinti: UYKU };
    }
    const kesinti = ak + coz + TOPARLANMA;            // hafif gece olayi sabaha kalir
    ekle(s.ekip, sabah(t), kesinti);
    return { ...ort, kapanis: (geri ? sabah(t) - t : ilkYanit) + ak + coz, uyandi: false, kesinti };
  };

  const olaylar = bicim === "yok" ? [] : OLAY;
  for (let t = 0; t < 200; t++) {
    for (const o of olaylar.filter((x) => x.tur === t)) kayit.push({ o, ...isle(o, t) });
    for (const [e, sure] of plan[t] ?? []) {
      const k = ekip[e];
      k.mesgul += sure;
      const d = Math.min(k.yapilan, YENIDEN_TAVAN);   // kesinti kalemin ortasina dusmusse
      k.yapilan -= d; k.yenidenIs += d;
    }
    if (gece(t)) continue;                            // mesai disinda kalem ilerlemez
    for (const e of EKIPLER) {
      const k = ekip[e];
      if (k.bitis !== null) continue;
      if (k.mesgul > 0) { k.mesgul--; k.cikan++; continue; }
      if (++k.yapilan < KALEM_IS[k.i]) continue;
      k.yapilan = 0; k.i++;
      if (k.i >= KALEM_IS.length) k.bitis = t + 1;
    }
  }
  const top = (f) => EKIPLER.reduce((a, e) => a + f(ekip[e]), 0);
  const ort = (f) => (kayit.length ? kayit.reduce((a, x) => a + f(x), 0) / kayit.length : 0);
  return { kayit, ekip,
    ilk: ort((x) => x.ilk).toFixed(1), kapanis: ort((x) => x.kapanis).toFixed(1),
    eld: kayit.reduce((a, x) => a + x.eld, 0), geri: kayit.filter((x) => x.geri).length,
    uyandi: kayit.filter((x) => x.uyandi).length,
    cikan: top((k) => k.cikan), yenidenIs: top((k) => k.yenidenIs),
    son: Math.max(...EKIPLER.map((e) => ekip[e].bitis)) };
}
```

```js
// devir/olc.mjs — devir sozlesmesi, iki devir bicimi, devredilemeyenin bedeli, ekip siniri.
import { kos, SOZLESME, OLAY, gece } from "./nobet.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 ort = (a) => (a.length ? (a.reduce((s, x) => s + x, 0) / a.length).toFixed(1) : "-");
const SORUMLULUK = ["kosum", "ilk-yanit", "yeniden-baslatma", "yapilandirma"];

const kalem = SOZLESME.flatMap((s) => SORUMLULUK.map((c) => s.hak[c]));
const neden = ["bilgi", "arac", "yordam"];
const say = (x) => kalem.filter((k) => k === x).length;
console.log(`sozlesme: ${kalem.length} kalem, devredilen ${say("+")}, devredilemeyen ` +
  `${kalem.length - say("+")} (${neden.map((n) => `${n} ${say(n)}`).join(", ")})`);
const R = { yok: kos("yok"), tam: kos("tam"), paylasimli: kos("paylasimli"),
  yordam: kos("tam", "yordam") };
console.log(`\n${OLAY.length} olay, ${OLAY.filter((o) => gece(o.tur)).length} tanesi mesai disi, ` +
  `${OLAY.filter((o) => o.agir).length} tanesi agir; olaysiz akis ${R.yok.son}. turda biter`);

const O = [-30, 11, 18, 22];
console.log("\n1. ayni olay kumesi iki devir biciminde (ucuncu sutun: karsit kosum)");
yaz(O, "olcu", "tam devir", "paylasimli nobet", "tam devir + 3 yordam");
const OLCU = [["ilk yanit gecikmesi (tur)", "ilk"], ["kapanis gecikmesi (tur)", "kapanis"],
  ["el degistirme", "eld"], ["geri donen olay", "geri"], ["gece uyandirma", "uyandi"],
  ["akistan cikan tur", "cikan"], ["yeniden is (tur)", "yenidenIs"],
  ["gelistirme akisinin sonu", "son"]];
for (const [ad, a] of OLCU) yaz(O, ad, R.tam[a], R.paylasimli[a], R.yordam[a]);

const N = [-10, 7, 15, 15, 17];
console.log("\n2. tam devirde geri donen olayin nedeni");
yaz(N, "neden", "olay", "ort. kapanis", "kesinti turu", "gece uyandirma");
for (const n of neden) {
  const g = R.tam.kayit.filter((x) => x.neden === n);
  yaz(N, n, g.length, ort(g.map((x) => x.kapanis)), g.reduce((s, x) => s + x.kesinti, 0),
    g.filter((x) => x.uyandi).length);
}

const M = [-24, 7, 15, 20];
console.log("\n3. servis ekip siniriyla ortusuyor mu (tam devir)");
yaz(M, "servis", "olay", "ort. kapanis", "olay basina el deg.");
for (const [ad, f] of [["tek ekibin", (x) => x.s.dokunan === 1],
  ["birden cok ekibin", (x) => x.s.dokunan > 1]]) {
  const g = R.tam.kayit.filter(f);
  yaz(M, ad, g.length, ort(g.map((x) => x.kapanis)), ort(g.map((x) => x.eld)));
}
```

```
sozlesme: 28 kalem, devredilen 20, devredilemeyen 8 (bilgi 3, arac 2, yordam 3)

14 olay, 7 tanesi mesai disi, 11 tanesi agir; olaysiz akis 56. turda biter

1. ayni olay kumesi iki devir biciminde (ucuncu sutun: karsit kosum)
olcu                            tam devir  paylasimli nobet  tam devir + 3 yordam
ilk yanit gecikmesi (tur)             1.0               1.6                   1.0
kapanis gecikmesi (tur)               5.0               3.8                   4.1
el degistirme                          24                16                    21
geri donen olay                         8                 0                     5
gece uyandirma                          3                 5                     1
akistan cikan tur                      37                54                    27
yeniden is (tur)                        9                20                    10
gelistirme akisinin sonu               94               105                    84

2. tam devirde geri donen olayin nedeni
neden        olay   ort. kapanis   kesinti turu   gece uyandirma
bilgi           3            6.3             15                1
arac            2            6.0             12                0
yordam          3            7.0             10                2

3. servis ekip siniriyla ortusuyor mu (tam devir)
servis                     olay   ort. kapanis olay basina el deg.
tek ekibin                   12            4.7                 1.5
birden cok ekibin             2            7.0                 3.0
```

Sayılar **ölçüm** sınıfındadır; girdileri yukarıdaki varsayımlardır. Yirmi sekiz kalemin yirmisi
devredilir ve sözleşme çizelgesi şunu söyler: **koşum ile ilk yanıt yedi servisin yedisinde de
devredilmiştir**, devredilemeyen sekizin tamamı yeniden başlatma ile yapılandırma sütunlarındadır.
Devir, servisi ayakta tutmakta değil, ona dokunmak gerektiğinde durur.

## Tam Devir ile Paylaşımlı Nöbet

Birinci tablonun ilk iki sütunu aynı on dört olayı iki biçimde karşılar. Tam devirde nöbetçi
işletim ekibidir ve ilk yanıt gecikmesi gece gündüz ayrımı olmadan 1,0 turdur; paylaşımlı nöbette
ilk yanıtı yazan ekip verir ve gecikme 1,6 tura çıkar, çünkü gece gelen hafif olay sabahı bekler.
Kapanışta sıra tersine döner: paylaşımlı nöbet 3,8, tam devir 5,0 turda kapatır. Fark, sekiz olayın
çözülemeyip yazan ekibe geri dönmesidir; her geri dönüş bir el değiştirme ve bağlamın ikinci elden
kurulmasıdır (24'e karşı 16 el değiştirme).

Fatura alt satırlardadır. Olay yokken üç ekip işini 56. turda bitirir; tam devirde akış 94.,
paylaşımlıda 105. tura uzar, akıştan çıkan tur 37'ye karşı 54 ve yeniden iş 9'a karşı 20'dir. Gece
uyandırma da paylaşımlıda yüksektir (5'e karşı 3): tam devirde yalnız devredilemeyen ağır gece
olayı uyandırır. **Paylaşımlı nöbet olayı daha hızlı kapatır ve bunu akıştan öder.**

## Devredilemeyenin Bedeli

İkinci tablo geri dönen sekiz olayı nedenine göre ayırır. En pahalı neden **yazılmamış
yordam**dır: üç olay, ortalama 7,0 tur kapanış ve üç gece uyandırmanın ikisi. Bilgi eksikliği üç
olayda 6,3 tur ve en yüksek kesinti turunu (15) üretir; araç eksikliği iki olayda 6,0 turdur.

Birinci tablonun üçüncü sütunu yordamın fiyatını verir: üç yordam yazılınca geri dönen olay 8'den
5'e, gece uyandırma 3'ten 1'e, akıştan çıkan tur 37'den 27'ye ve akışın sonu 94'ten 84. tura iner.
**Yazılmamış yordam bir belge eksiği değil, on turluk akış gecikmesi ve iki gece uyandırmadır.**

## Olay Hangi Ekip Sınırına Düşüyor

Üçüncü tablo olayları servisin ekip sınırıyla örtüşmesine göre ayırır. Tek ekibin servislerinde on
iki olay 4,7 turda ve olay başına 1,5 el değiştirmeyle kapanır; üç ekibin dokunduğu `ortak-kayit`
servisinde iki olay 7,0 turda ve 3,0 el değiştirmeyle. Nedeni sözleşmededir: o servisin
devredilemeyen iki kalemi de `bilgi` nedenlidir, çünkü bilgi tek bir ekipte durmaz. **Ekip
sınırıyla örtüşmeyen servis yalnız yazılırken değil, gece de pahalıdır.**

## Özet

- Devir sözleşmesi 28 kaleme ayrıldı; 20'si devredildi, 8'i devredilemedi (bilgi 3, araç 2,
  yordam 3) ve devredilemeyenlerin tamamı yeniden başlatma ile yapılandırma sütunundadır.
- Aynı 14 olay tam devirde 5,0, paylaşımlı nöbette 3,8 turda kapanır; ilk yanıt tersinedir (1,0'a
  karşı 1,6) ve el değiştirme 24'e karşı 16'dır.
- Bedel geliştirme akışındadır: olaysız akış 56. turda biterken tam devirde 94., paylaşımlıda
  105. tura uzar; akıştan çıkan tur 37'ye karşı 54 ve yeniden iş 9'a karşı 20'dir.
- Üç yazılmamış yordam yazıldığında geri dönen olay 8'den 5'e, gece uyandırma 3'ten 1'e ve akış
  sonu 94'ten 84. tura iner; üç ekibin dokunduğu servisin olayı 7,0 turda ve 3,0 el değiştirmeyle
  kapanır (tek ekipte 4,7 ve 1,5).

## Kurs Kapanışı

| Ders | Akış nesnesi | El değiştirme / bekleme / yeniden iş | Mimariyle uyumun bedeli |
|---|---|---|---|
| Yaşam Döngüsü Modelleri | 18 kalem, 4 döngü | 125 → 120 / 243 → 18 tur / 105 → 90 birim | yanlış sınır gecikmesi 14,8 → 7,8 tur |
| Çevik Çerçeveler | 30 kalem, 1–6 hafta | yarım kalan 8 → 0 / akış 12,5 → 31,2 gün / 19 → 23 adam-gün | 75 bağımlılık bağı yeniden işi belirler |
| Akış Tabanlı Yönetim | 60 kalem, sınır 1–16 | teslim 118,5 → 17,3 gün / bekleme payı %0 → %84,1 | sınır ekip değil iş sınırı; 195,9 adam-gün geçiş kaybı |
| Ölçekli Çerçeveler | 40 kalem, 1–12 ekip | eşgüdüm turu 0 → 66 / kalem başına 0 → 5,9 dönem | ortak kanal karesel; en az bedel 3 ekipte |
| Mühendislik Pratikleri | 48 kalem, 2–40 saat | olay 21 → 2 / gecikme 8,0 → 21,4 saat / 82 → 132 saat | yeniden iş aynı modüldeki kalemle büyür |
| Conway Yasası | 12 kalem, iki bölünme | 24 → 17 / 203 → 55 tur / 24 → 15 | sınırı geçen bağ 40/43 → 32/43; yolsuz ekip arası 16 → 0 |
| Ekip Topolojileri | 12 kalem, üç düzen | 24 / 17 / 25 — 203 / 55 / 78 tur — 24 / 15 / 22 | yük 1–13'ten 3–9'a iner, yinelenen uzmanlık 18 / 18 / 24 |
| Tahmin ve Planlama | 12 kalemin süresi | beklemeyi tahmine sokmak hatayı %58,4 → %23,5 yapar | 3+ ekipte bekleme payı %51,7 ve hata %72,2 (1–2 ekipte %24,3 ve %44,6) |
| Değişiklik Yönetimi | 8 kalem, 6 istek | 31 / 38 — 44 / 133 tur — 8 / 4 tur | sınır dışına düşen istek teslimi 23 yerine 28 tur yapar |
| İşletim Devri | 14 olay, 28 kalem | 24 / 16 — kapanış 5,0 / 3,8, akıştan çıkan 37 / 54 — 9 / 20 tur | üç ekibin servisinde el değiştirme 1,5 yerine 3,0 |

**Süreç, Ekip ve Teslimat** kursunun kuralı budur: **süreç ve ekip kararları mimariyi işin
beklediği yerden biçimlendirir.** Hiçbir ders bir süreci kendiliğinden iyi bulmadı; her biri aynı
iş kalemi kümesinde koşturuldu ve kazandığı yerde neyi kaybettiği sayıldı.

**Yazılım Mimarlığı** müfredatı burada biter. Beş kursun beş ölçü ekseni tek cümlede toplanır:
karar bir nesnedir ve izlenebilirliği ölçülür (**Mimarın Rolü**), belge yanıtladığı soruyla ölçülür
(**Mimari Karar ve Dokümantasyon**), kurum ölçeğinde ölçü bağdır (**Kurumsal Bağlam ve
Tümleştirme**), kural makinece denetlenebildiği ölçüde yönetilebilir (**Kalite Nitelikleri ve
Yönetişim**), süreç ve ekip kararları işin beklediği yerden ölçülür (**Süreç, Ekip ve Teslimat**).
