--- title: 'Katmanlı Diyagram Yaklaşımı' source: 'https://academia.sh/tr/kurslar/mimari-dokumantasyon/katmanli-diyagram-yaklasimi' course: 'Mimari Karar ve Dokümantasyon' language: tr updated: '2026-08-17T18:10:33+00:00' license: 'CC BY-SA 4.0' --- # Katmanlı Diyagram Yaklaşımı Aynı sistemin bağlam, kap, bileşen ve kod düzeyinde modellenmesi: düzey başına düğüm ve kenar sayısı, bir sorunun hangi düzeyde yanıtlandığı, yanlış düzeyde bakan okuyucunun okuduğu gereksiz düğüm ve dört düzeyi bakımda tutmanın başabaş noktası. Önceki ders sistemi ilgi eksenine göre dört görünüme böldü ve her görünümün yanıtladığı soruyu saydı. Kesilmeyen bir eksen kaldı: **ayrıntı.** Bölgesel kütüphane ağının dışarıyla ne alışveriş ettiğini soran biri de, gecikme cezası formülünün neyi çağırdığını soran biri de aynı modül listesine bakmak zorunda. Birincisi için liste fazla kalabalık, ikincisi için fazla kaba. Katmanlı diyagram yaklaşımı bu ekseni keser. Aynı sistem **dört ölçek düzeyinde** modellenir: **bağlam düzeyi** sistemi tek bir kutu olarak ve dışarıdaki taraflarla ilişkisini; **kap düzeyi** sistemin içindeki ayrı çalışan ve ayrı yayınlanan birimleri; **bileşen düzeyi** bir kabın içindeki sorumluluk parçalarını; **kod düzeyi** bir bileşenin içindeki işlevleri gösterir. Düzeyler farklı şeyleri değil, **aynı şeyi farklı ölçekte** gösterir. İki terimin sınırı yazılı olsun. **Kap**, ayrı çalışan ve ayrı yayınlanan birimdir — bir uç uygulaması, bir servis, bir veri deposu, bir ileti yolu. **Bileşen** daha önce modül içi sorumluluk parçası olarak kurulmuştu; buradaki fark bağlamdır: orada bileşen bir kod tabanının içindeki ayrılabilir birimdi, burada **bir kabın içindeki** ayrılabilir birimdir ve kendi başına yayınlanmaz. ## Model Diyagram çizilmiyor. Çizimin altındaki yapı modelleniyor: düğümler, kenarlar ve düğümleri birbirine bağlayan ağaç. Ağaç elle yazılmıştır (**GR5**), bileşen düzeyindeki bağımlılıklar da öyle (**GR6**). Kod düzeyindeki kenarlar ikisinden türetiliyor: her bileşen bağımlılığı kod düzeyinde tek bir öge çiftiyle gerçekleşir (**GR7**) ve her bileşenin ögeleri kendi içinde bir zincirle bağlanır (**GR8**). Tohum görünür. Üst düzeylerin kenarları hesaplanır, yazılmaz: bir kod kenarının iki ucu istenen düzeydeki atalarıyla değiştirilir, kendine dönen kenarlar atılır, kalanlar tekilleştirilir. Buna **kenarın yükseltilmesi** deniyor. Yöntemin doğruluğu ölçülebilir bir iddiadır ve çıktıda sınanıyor: elle yazılan bileşen kenarları, kod kenarlarından yükseltilince geri gelmelidir. Soru kümesi yine bir veri yapısıdır (**GR9**). Her sorunun bir hedef düğümü ve bir **yanıt düzeyi** var: hedefin komşularının ayırt edilebildiği en sığ düzey. Okuma maliyeti şöyle sayılıyor: yanıt düzeyinde okunan düğüm, hedef ile komşularıdır. Daha derin bir düzeyde okuyan biri hedefin ve komşularının bütün alt düğümlerini okumak zorundadır. Daha sığ bir düzeyde ise hedef kendi atasının içinde kaybolur ve soru **yanıtsız kalır**. ```js // gorunum/olcek.mjs — MODEL bolgesel kutuphane agi dort olcek duzeyinde: baglam, kap, // bilesen, kod. Gercek bir kurum degildir; agac ve bilesen kenarlari elle yazilmistir. // AGAC — kap > bilesen > kod ogesi (GR5) const AGAC = { "web-portali": { "oturum-ucu": ["giris-akisi", "oturum-cerezi", "sifre-sifirlama"], "arama-ucu": ["sorgu-formu", "sonuc-listesi", "suzgec"], "hesap-ucu": ["odunc-listesi", "ceza-ozeti"] }, "personel-uygulamasi": { "tezgah-ucu": ["odunc-ekrani", "iade-ekrani", "ceza-ekrani"], "yonetim-ucu": ["uye-yonetimi", "rapor-ekrani"] }, "kiosk-ucu": { "kiosk-arayuz": ["kart-okuma", "hizli-odunc"], "kiosk-onbellek": ["yerel-katalog", "yerel-sure"] }, "odunc-servisi": { "odunc-cekirdek": ["odunc-ac", "iade-al", "uzatma"], "odunc-kural": ["sure-hesabi", "limit-denetimi", "gecikme-cezasi"], ayirtma: ["ayirtma-sirasi", "ayirtma-bildirimi"] }, "uye-servisi": { "uye-kayit": ["uye-olustur", "uye-guncelle", "kart-baglama"], "uye-ceza": ["ceza-birikimi", "ceza-tahsilat"] }, "katalog-tumlestirme": { "katalog-baglayici": ["dis-sorgu", "kayit-donusturme", "yeniden-deneme"], "katalog-onbellek": ["onbellek-anahtari", "gecerlilik-suresi"] }, "envanter-servisi": { "sube-envanter": ["kopya-durumu", "raf-yeri"], "sube-esitleme": ["esitleme-isi", "catisma-cozumu"] }, "bildirim-servisi": { "bildirim-kuyruk": ["kuyruga-yaz", "kuyruktan-oku"], "bildirim-eposta": ["ileti-govdesi", "gonderim-denemesi"] }, "rapor-servisi": { "rapor-gunluk": ["gunluk-toplam", "sube-kirilimi"], "rapor-toplu": ["aylik-ozet", "arsiv-yazimi"] }, "ana-veritabani": { "iliskisel-sema": ["uye-tablosu", "kopya-tablosu", "odunc-tablosu", "ceza-tablosu"] }, "olay-yolu": { "konu-yonlendirme": ["konu-tanimi", "abonelik"] }, onbellek: { "anahtar-deger": ["yazma", "okuma", "sureli-silme"] }, }; const SISTEM = "kutuphane-agi"; const DIS = ["uye", "personel", "dis-katalog", "eposta-gecidi", "kimlik-saglayici"]; // BILESEN_KENAR — bilesen duzeyindeki bagimliliklar (GR6); elle secilmistir const BILESEN_KENAR = [ ["uye", "arama-ucu"], ["uye", "oturum-ucu"], ["uye", "hesap-ucu"], ["uye", "kiosk-arayuz"], ["personel", "tezgah-ucu"], ["personel", "yonetim-ucu"], ["oturum-ucu", "kimlik-saglayici"], ["oturum-ucu", "uye-kayit"], ["arama-ucu", "katalog-onbellek"], ["arama-ucu", "sube-envanter"], ["hesap-ucu", "odunc-cekirdek"], ["hesap-ucu", "uye-ceza"], ["tezgah-ucu", "odunc-cekirdek"], ["tezgah-ucu", "uye-ceza"], ["tezgah-ucu", "sube-envanter"], ["yonetim-ucu", "uye-kayit"], ["yonetim-ucu", "rapor-gunluk"], ["kiosk-arayuz", "odunc-cekirdek"], ["kiosk-arayuz", "kiosk-onbellek"], ["kiosk-onbellek", "katalog-onbellek"], ["odunc-cekirdek", "odunc-kural"], ["odunc-cekirdek", "iliskisel-sema"], ["odunc-cekirdek", "konu-yonlendirme"], ["odunc-cekirdek", "sube-envanter"], ["ayirtma", "odunc-cekirdek"], ["ayirtma", "bildirim-kuyruk"], ["ayirtma", "iliskisel-sema"], ["uye-kayit", "iliskisel-sema"], ["uye-ceza", "uye-kayit"], ["uye-ceza", "odunc-kural"], ["uye-ceza", "iliskisel-sema"], ["katalog-baglayici", "dis-katalog"], ["katalog-onbellek", "katalog-baglayici"], ["katalog-onbellek", "anahtar-deger"], ["sube-envanter", "iliskisel-sema"], ["sube-envanter", "konu-yonlendirme"], ["sube-esitleme", "sube-envanter"], ["sube-esitleme", "konu-yonlendirme"], ["sube-esitleme", "katalog-baglayici"], ["bildirim-kuyruk", "konu-yonlendirme"], ["bildirim-kuyruk", "iliskisel-sema"], ["bildirim-eposta", "bildirim-kuyruk"], ["bildirim-eposta", "eposta-gecidi"], ["rapor-gunluk", "iliskisel-sema"], ["rapor-toplu", "iliskisel-sema"], ["rapor-toplu", "sube-envanter"], ]; // ---- agactan turetilen eslemeler ---- const KAPLAR = Object.keys(AGAC); const UST = { bilesen: {}, kap: {} }; // kod->bilesen, bilesen->kap for (const k of KAPLAR) for (const b of Object.keys(AGAC[k])) { UST.kap[b] = k; for (const c of AGAC[k][b]) UST.bilesen[c] = b; } const BILESENLER = Object.keys(UST.kap); const KODLAR = Object.keys(UST.bilesen); const DUZEY = ["baglam", "kap", "bilesen", "kod"]; const dis = (n) => DIS.includes(n); const seviye = (n) => (dis(n) ? -1 : n === SISTEM ? 0 : KAPLAR.includes(n) ? 1 : BILESENLER.includes(n) ? 2 : 3); const temsil = (n, L) => { let m = n; while (!dis(m) && seviye(m) > L) m = seviye(m) === 3 ? UST.bilesen[m] : seviye(m) === 2 ? UST.kap[m] : SISTEM; return m; }; const icerik = { baglam: [SISTEM], kap: KAPLAR, bilesen: BILESENLER, kod: KODLAR }; const dugumler = (L) => [...icerik[DUZEY[L]], ...DIS]; const altlar = (n, L) => (seviye(n) >= L || dis(n) ? [temsil(n, L)] : dugumler(L).filter((m) => temsil(m, seviye(n)) === n)); // ---- kod duzeyi kenarlar: her bilesen kenari tek bir oge ciftiyle gerceklesir (GR7), // her bilesenin ogeleri kendi icinde zincirle baglanir (GR8) ---- function uretec(tohum) { let s = tohum >>> 0; return () => (s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32; } const rast = uretec(31607); // tohum gorunur const kodOgesi = (n) => (dis(n) ? n : AGAC[UST.kap[n]][n][Math.floor(rast() * AGAC[UST.kap[n]][n].length)]); const KOD_KENAR = BILESEN_KENAR.map(([a, b]) => [kodOgesi(a), kodOgesi(b)]); for (const b of BILESENLER) { const g = AGAC[UST.kap[b]][b]; for (let i = 1; i < g.length; i++) KOD_KENAR.push([g[i - 1], g[i]]); } const kenarlar = (L) => [...new Set(KOD_KENAR.map(([a, b]) => [temsil(a, L), temsil(b, L)]) .filter(([a, b]) => a !== b).map(([a, b]) => `${a}->${b}`))].map((s) => s.split("->")); // ---- duzey basina dugum ve kenar ---- const sut = (s, n) => String(s).padEnd(n); console.log(sut("duzey", 10) + sut("dugum", 8) + sut("kenar", 8) + "ic dugum + dis taraf"); console.log("-".repeat(52)); DUZEY.forEach((d, L) => console.log(sut(d, 10) + sut(dugumler(L).length, 8) + sut(kenarlar(L).length, 8) + `${icerik[d].length} + ${DIS.length}`)); const geriGelen = new Set(kenarlar(2).map((e) => e.join("->"))); const elYazimi = BILESEN_KENAR.map((e) => e.join("->")); console.log(`\nel yazimi ${elYazimi.length} bilesen kenarinin ${elYazimi.filter((e) => geriGelen.has(e)).length}'i kod kenarlarindan yukseltilince geri geliyor`); // ---- soru kumesi: her sorunun yanit duzeyi ve hedefi (GR9) ---- const SORU = [ { id: "D01", metin: "ag disaridan hangi taraflarla konusuyor", hedef: SISTEM, duzey: 0 }, { id: "D02", metin: "kimlik saglayici sistemin icinde mi disinda mi", hedef: "kimlik-saglayici", duzey: 0 }, { id: "D03", metin: "odunc servisi hangi kaplarla konusuyor", hedef: "odunc-servisi", duzey: 1 }, { id: "D04", metin: "eposta gecidine hangi kap baglaniyor", hedef: "eposta-gecidi", duzey: 1 }, { id: "D05", metin: "ana veritabanina hangi kaplar yaziyor", hedef: "ana-veritabani", duzey: 1 }, { id: "D06", metin: "olay yolunu hangi kaplar kullaniyor", hedef: "olay-yolu", duzey: 1 }, { id: "D07", metin: "odunc kurali bileseni neye bagli", hedef: "odunc-kural", duzey: 2 }, { id: "D08", metin: "katalog onbellegini hangi bilesenler okuyor", hedef: "katalog-onbellek", duzey: 2 }, { id: "D09", metin: "ceza hesabi hangi bilesenlere dokunuyor", hedef: "uye-ceza", duzey: 2 }, { id: "D10", metin: "bildirim kuyruguna hangi bilesen yaziyor", hedef: "bildirim-kuyruk", duzey: 2 }, { id: "D11", metin: "gecikme cezasi hesabi neyi cagiriyor", hedef: "gecikme-cezasi", duzey: 3 }, { id: "D12", metin: "sure hesabi hangi ogeye bagli", hedef: "sure-hesabi", duzey: 3 }, { id: "D13", metin: "uzatma islevi neye dokunuyor", hedef: "uzatma", duzey: 3 }, { id: "D14", metin: "onbellek anahtari nerede uretiliyor", hedef: "onbellek-anahtari", duzey: 3 }, ]; const komsu = (n, L) => { const t = temsil(n, L); return [...new Set(kenarlar(L).filter((e) => e.includes(t)).flat())].filter((m) => m !== t); }; const okuma = (s, L) => (L < s.duzey ? null : L === s.duzey ? 1 + komsu(s.hedef, L).length : altlar(s.hedef, L).length + komsu(s.hedef, s.duzey).reduce((t, m) => t + altlar(m, L).length, 0)); console.log("\nsoru yanit duzeyi okunan dugum kod duzeyinde gereksiz"); console.log("-".repeat(60)); let enAz = 0, hepsiKod = 0; for (const s of SORU) { const az = okuma(s, s.duzey), kod = okuma(s, 3); enAz += az; hepsiKod += kod; console.log(sut(s.id, 6) + sut(DUZEY[s.duzey], 14) + sut(az, 14) + sut(kod, 15) + (kod - az)); } console.log("-".repeat(60)); console.log(sut("toplam", 20) + sut(enAz, 14) + sut(hepsiKod, 15) + (hepsiKod - enAz)); console.log("\nayni soru dort duzeyde okunursa:"); console.log((sut("soru", 6) + DUZEY.map((d) => sut(d, 10)).join("")).trimEnd()); for (const id of ["D01", "D03", "D11"]) { const s = SORU.find((x) => x.id === id); console.log((sut(s.id, 6) + DUZEY.map((d, L) => sut(okuma(s, L) ?? "yanit yok", 10)).join("")).trimEnd()); } console.log("\nyanit duzeyi dagilimi: " + DUZEY.map((d, L) => `${d}=${SORU.filter((s) => s.duzey === L).length}`).join(", ")); DUZEY.forEach((d, L) => { const yanit = SORU.filter((s) => s.duzey <= L); const yok = SORU.length - yanit.length; console.log(`${sut("yalniz " + d, 18)}yanit ${sut(`${yanit.length}/${SORU.length}`, 8)}yanitsiz ${sut(yok, 4)}okuma ${yanit.reduce((t, s) => t + okuma(s, L), 0)}`); }); // ---- bakim ve basabas ---- // GR10: bir dugumu okumak ile bir dugumu guncel tutmak esit maliyet sayilir const bakimDort = DUZEY.reduce((t, d, L) => t + dugumler(L).length, 0); const bakimKod = dugumler(3).length; const kazanc = hepsiKod - enAz; console.log(`\ndort duzey ${bakimDort} dugum bakimda tutar, yalniz kod duzeyi ${bakimKod}; fark ${bakimDort - bakimKod}`); console.log(`bir soru turu ${kazanc} gereksiz dugum okumasindan kurtariyor (${enAz} yerine ${hepsiKod})`); console.log(`basabas (GR10): soru kumesi her ${(kazanc / (bakimDort - bakimKod)).toFixed(2)} degisiklik turunda bir kez sorulursa fazla bakim geri odenir`); ``` ``` duzey dugum kenar ic dugum + dis taraf ---------------------------------------------------- baglam 6 5 1 + 5 kap 17 30 12 + 5 bilesen 28 46 23 + 5 kod 61 79 56 + 5 el yazimi 46 bilesen kenarinin 46'i kod kenarlarindan yukseltilince geri geliyor soru yanit duzeyi okunan dugum kod duzeyinde gereksiz ------------------------------------------------------------ D01 baglam 6 61 55 D02 baglam 2 57 55 D03 kap 9 44 35 D04 kap 2 5 3 D05 kap 6 29 23 D06 kap 4 18 14 D07 bilesen 3 8 5 D08 bilesen 5 13 8 D09 bilesen 6 17 11 D10 bilesen 5 12 7 D11 kod 3 3 0 D12 kod 3 3 0 D13 kod 5 5 0 D14 kod 3 3 0 ------------------------------------------------------------ toplam 62 278 216 ayni soru dort duzeyde okunursa: soru baglam kap bilesen kod D01 6 17 28 61 D03 yanit yok 9 18 44 D11 yanit yok yanit yok yanit yok 3 yanit duzeyi dagilimi: baglam=2, kap=4, bilesen=4, kod=4 yalniz baglam yanit 2/14 yanitsiz 12 okuma 8 yalniz kap yanit 6/14 yanitsiz 8 okuma 51 yalniz bilesen yanit 10/14 yanitsiz 4 okuma 112 yalniz kod yanit 14/14 yanitsiz 0 okuma 278 dort duzey 112 dugum bakimda tutar, yalniz kod duzeyi 61; fark 51 bir soru turu 216 gereksiz dugum okumasindan kurtariyor (62 yerine 278) basabas (GR10): soru kumesi her 4.24 degisiklik turunda bir kez sorulursa fazla bakim geri odenir ``` ## Düzeylerin Büyüklüğü Dört düzeyin düğüm sayısı 6, 17, 28 ve 61; kenar sayısı 5, 30, 46 ve 79. Bağlam düzeyi bir sistem kutusu ve beş dış taraftan ibaret; kod düzeyinde elli altı iç düğüm var. Ölçek düzeyleri arasındaki büyüme kabaca ikişer katlıdır ve bu bilinçli bir tasarımdır: bir düzeyden diğerine geçen okuyucu her adımda gördüğü düğüm sayısını iki katına çıkarır, elli katına değil. Yükseltme yönteminin doğruluğu çıktının ikinci satırında sınanıyor: elle yazılan kırk altı bileşen kenarının kırk altısı da kod kenarlarından yükseltilince geri geliyor. Üst düzeyler bağımsız belgeler değil, aynı grafın kaba çözünürlükte okunmuş hâlidir — türetildikleri sürece alt düzeyle çelişemezler, elle yazıldıklarında çelişebilirler. ## Soru Hangi Düzeyde Yanıtlanır On dört soru dört düzeye eşit dağılmıyor: ikisi bağlam, dördü kap, dördü bileşen, dördü kod düzeyinde yanıt buluyor. Toplam okuma maliyeti, her soru kendi yanıt düzeyinde okunduğunda **62 düğüm.** Bu, dersin ölçüsünün sıfır noktasıdır: on dört sorunun hepsini yanıtlamak için gereken en az okuma. Aynı on dört soru yalnız kod düzeyine bakılarak yanıtlansaydı okunan düğüm sayısı **278** olurdu. Fark **216 gereksiz düğüm** — sorulan şeyin yanıtına katkısı olmayan, sırf doğru ölçek elde olmadığı için okunan düğümler. En pahalısı ilk iki soru: ağın dışarıyla ilişkisini soran biri bağlam düzeyinde altı düğüm okur, kod düzeyinde altmış bir. Elli beş düğüm, yanıtı değiştirmeyen ayrıntıdır. Kod düzeyindeki dört soruda gereksiz düğüm sıfır; katmanlı yaklaşım onlara bir şey kazandırmıyor. Kazanç, sorunun yanıt düzeyi ile okuyucunun baktığı düzey arasındaki mesafeyle büyüyor. ## Yanlış Düzeyin İki Yönü "Aynı soru dört düzeyde okunursa" tablosu maliyeti tek soru üzerinde gösteriyor. Ağın dış ilişkisini soran D01 bağlam düzeyinde 6, kap düzeyinde 17, bileşen düzeyinde 28, kod düzeyinde 61 düğüm okutuyor — yanıt her düzeyde bulunabiliyor ama bedeli on kata çıkıyor. Ödünç servisinin komşularını soran D03 bağlam düzeyinde **yanıtsız**: o düzeyde ödünç servisi diye bir düğüm yok, sistem kutusunun içinde kalmış. Gecikme cezası hesabını soran D11 ilk üç düzeyin hepsinde yanıtsız. İki yön de bir sayı üretiyor ve sayılar simetrik değil. **Fazla derine bakmak** yanıtı verir ama gereksiz düğüm okutur; ölçülebilir, tahammül edilebilir bir israftır. **Fazla yükseğe bakmak** yanıt vermez; okuyucu ya vazgeçer ya da tahmin eder. Alt tablo bunu düzen düzeyinde sayıyor: yalnız bağlam düzeyini tutan bir belge on dört sorunun ikisini yanıtlıyor, on ikisi yanıtsız. Yalnız kap düzeyi altısını, yalnız bileşen düzeyi onunu yanıtlıyor. Yalnız kod düzeyi hepsini yanıtlıyor ama 278 düğüm okutuyor. ## Bakımın Bedeli Dört düzeyi birden tutmak 112 düğümü bakımda tutmak demektir; yalnız kod düzeyini tutmak 61. Fark 51 düğümdür ve bu fark bedavaya gelmiyor: kap ve bileşen düzeyindeki her düğümün karşılığı kod tarafında değiştikçe güncellenmesi gerekir. Karşılığında kazanılan şey soru turu başına 216 gereksiz düğüm okumasıdır. İki büyüklük farklı birimlerde olduğu için bir varsayım gerekiyor: bir düğümü okumak ile bir düğümü güncel tutmak eşit maliyet sayılıyor (**GR10**). Bu varsayımla başabaş noktası şudur: soru kümesi her **4,24 değişiklik turunda** bir kez sorulursa dört düzeyin fazla bakımı geri ödenir. Soru sıklığı bunun altındaysa — yani belgeye kimse bakmıyor, kod ise sürekli değişiyorsa — dört düzeyi tutmak zarar eder. Sayının kendisi modelin girdilerine bağlıdır; asıl taşınan sonuç şudur: katmanlı düzenin kârı **okunma sıklığına** bağlıdır, belgenin güzelliğine değil. ## Özet - Katmanlı yaklaşım aynı sistemi bağlam, kap, bileşen ve kod düzeyinde modeller; düzeyler farklı şeyleri değil aynı şeyi farklı ölçekte gösterir. Kap ayrı çalışan ve ayrı yayınlanan birimdir, bileşen bir kabın içindeki ayrılabilir parçadır ve kendi başına yayınlanmaz. - Model ağda düğüm sayıları 6, 17, 28, 61; kenar sayıları 5, 30, 46, 79. Üst düzeylerin kenarları yazılmaz, kod kenarlarının uçları atalarıyla değiştirilerek yükseltilir; elle yazılan 46 bileşen kenarının 46'sı bu yolla geri geliyor. - On dört soru kendi yanıt düzeyinde okunduğunda toplam 62 düğüm okunuyor; hepsi kod düzeyinde yanıtlanmaya kalkılırsa 278 düğüm okunuyor ve aradaki 216 düğüm gereksizdir. - Fazla derine bakmak yanıtı pahalıya verir (D01 için 6 düğüm yerine 61), fazla yükseğe bakmak hiç vermez: D03 bağlam düzeyinde, D11 ilk üç düzeyin hepsinde yanıtsızdır. - Dört düzey 112 düğüm bakımda tutar, yalnız kod düzeyi 61; okuma ile bakım eşit maliyet sayılırsa (GR10) soru kümesi her 4,24 değişiklik turunda bir kez sorulduğunda fazla bakım geri ödenir. ## Sonraki Adım İki ders de düğüm ve kenardan oluşan tek bir yapıyı ölçtü: neyin neye bağlı olduğu. Sorulan soruların hepsi bu türdendi. Ama sonradan gelen birinin soruları hep "ne neye bağlı" biçiminde değil. "Ödünç isteği geldiğinde çağrılar hangi sırayla gider", "bir kopya hangi durumlardan geçer", "bu birim hangi makinede koşar" soruları düğüm–kenar yapısına bakarak yanıtlanamaz; sıra, durum ve yerleşim taşımayan bir gösterim bu soruların yanıtını içermez. Sonraki ders diyagram türlerini işlevleriyle ayırır — yapı gösteren, sıra gösteren, durum gösteren, dağıtım gösteren — ve şunu ölçer: soru başına doğru tür hangisi, yanlış türle yanıtlanmaya çalışılan soru hangi bilgiyi eksik bırakır, her tür kod değiştiğinde kaç ögesini güncellemek zorunda kalır.