Katmanlı Diyagram Yaklaşımı

Ö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.

// 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.