Bilişsel Yük

Önceki ders düşünsel sisteme geçmenin bir bedeli olduğunu gösterdi ama bedeli sabit varsaydı: her kayıt 1.4 saniye. Bu varsayım listedeki kayıt sayısı değişmediği sürece işe yarar. Katalog arayüzünde ise seçenek sayısı her ekranda başka bir değer alır: süzgeç panelinde yirmi dört ölçüt, sıralama açılırında beş, teslim şubesi listesinde altı.

Bu ders seçenek sayısıyla karar süresi arasındaki bağıntıyı kurar, ödünç alma akışındaki bağımsız karar noktalarını sayar ve yükün hata oranına dönüşümünü hesaplar. Çıkan sonuçlardan biri, alışılmış bir tasarım öğüdünün ölçüyle uyuşmadığını gösterecek.

Karar Süresi Seçenek Sayısının Logaritmasıdır

Eş olasılıklı $n$ seçenek arasından seçim yapmanın süresi, seçenek sayısıyla değil seçeneklerin taşıdığı bilgi miktarıyla orantılıdır. Hick–Hyman bağıntısı bunu şöyle yazar:

$$T = a + b \cdot \log_2(n + 1)$$

Burada $a$ karar dışı sabit gecikmedir (algılama ve eylem), $b$ ise bit başına karar süresidir. $n + 1$ terimi “hiçbirini seçmeme” seçeneğini hesaba katar.

Bağıntının taşıdığı sezgi şudur: seçim, ikili bir arama gibi işler. Kullanıcı seçenekleri teker teker gözden geçirmez; kümeyi ardışık olarak ikiye böler. Seçenek sayısını iki katına çıkarmak süreye tek bir bit ekler.

Bilişsel yük (cognitive load) bu bitlerin toplamıdır: kullanıcının bir görevi tamamlamak için işlemek zorunda olduğu bilgi miktarı. Yük ölçülebilir bir büyüklük olduğu için tasarım kararı da ölçülebilir hâle gelir.

Ödünç Alma Akışının Yükünü Saymak

Aşağıdaki hesap üç şeyi yapıyor: seçenek sayısı–süre eğrisini çıkarıyor, düz liste ile gruplanmış listeyi karşılaştırıyor ve katalog arayüzünün ödünç alma akışındaki bağımsız karar noktalarını sayıp toplam yükü veriyor.

// yuk.mjs — Hick-Hyman karar suresi, gruplama ve ekrandaki karar noktalari

const A = 0.20;  // sn — karar disi sabit gecikme (algi + eylem)
const B = 0.15;  // sn/bit — bit basina karar suresi

const log2 = (x) => Math.log(x) / Math.LN2;
const esOlasiSure = (n) => A + B * log2(n + 1);          // Hick yasasi
const entropi = (p) => -p.reduce((t, x) => t + (x > 0 ? x * log2(x) : 0), 0);
const entropiliSure = (p) => A + B * entropi(p);          // Hyman genellemesi

// 1) Suzgec panelindeki secenek sayisinin karar suresine etkisi
console.log("secenek  bilgi (bit)  karar suresi");
for (const n of [2, 4, 8, 12, 16, 24, 32]) {
  console.log(`${String(n).padStart(7)} ${log2(n + 1).toFixed(3).padStart(12)} ${(esOlasiSure(n).toFixed(3) + " sn").padStart(13)}`);
}

// 2) Duz liste ile iki asamali gruplama karsilastirmasi (24 suzgec secenegi)
console.log("\n24 suzgec secenegi icin duzen karsilastirmasi");
const duz = esOlasiSure(24);
const grup = esOlasiSure(4) + esOlasiSure(6);      // once grup, sonra grup icinden
const grup3 = esOlasiSure(3) + esOlasiSure(8);
const grup2 = esOlasiSure(2) + esOlasiSure(12);
console.log(`duz liste (24)          ${duz.toFixed(3)} sn`);
console.log(`4 grup x 6 secenek      ${grup.toFixed(3)} sn   (fark ${(grup - duz).toFixed(3)} sn)`);
console.log(`3 grup x 8 secenek      ${grup3.toFixed(3)} sn   (fark ${(grup3 - duz).toFixed(3)} sn)`);
console.log(`2 grup x 12 secenek     ${grup2.toFixed(3)} sn   (fark ${(grup2 - duz).toFixed(3)} sn)`);

// 3) Kullanim dagilimi es olasili degilse: Hyman entropisi
console.log("\nkullanim dagilimi es olasili olmadiginda (24 secenek)");
const esOlasili = Array(24).fill(1 / 24);
// Gozlenen kullanim: uc suzgec agirlikli, kalan 21 seyrek
const gozlenen = [];
const agir = [0.34, 0.26, 0.17];
for (const p of agir) gozlenen.push(p);
for (let i = 0; i < 21; i++) gozlenen.push((1 - 0.77) / 21);
console.log(`es olasili dagilim      entropi ${entropi(esOlasili).toFixed(3)} bit   sure ${entropiliSure(esOlasili).toFixed(3)} sn`);
console.log(`gozlenen dagilim        entropi ${entropi(gozlenen).toFixed(3)} bit   sure ${entropiliSure(gozlenen).toFixed(3)} sn`);
console.log(`siklik sirasina koymanin kazanci: ${(entropiliSure(esOlasili) - entropiliSure(gozlenen)).toFixed(3)} sn`);
console.log(`gruplamanin kazanci (es olasili varsayimiyla):  ${(duz - grup).toFixed(3)} sn`);

// 4) Odunc alma akisindaki bagimsiz karar noktalarinin sayimi
// Her karar noktasi: kullanicinin secim yapmak zorunda oldugu, birbirinden bagimsiz alan.
const AKIS = [
  { ekran: "arama", noktalar: [["arama alani", 1], ["kapsam secimi", 3], ["siralama", 5]] },
  { ekran: "sonuc listesi", noktalar: [["suzgec paneli", 24], ["siralama", 5], ["sayfa boyutu", 4], ["kayit secimi", 20]] },
  { ekran: "kayit ayrinti", noktalar: [["nusha secimi", 3], ["odunc / rezerve / listeye ekle", 3]] },
  { ekran: "odunc onayi", noktalar: [["teslim subesi", 6], ["sure secimi", 3], ["hatirlatma tercihi", 4], ["onay", 2]] },
];
console.log("\nekran            karar noktasi  toplam bit  karar suresi");
let toplamBit = 0, toplamSure = 0, toplamNokta = 0;
for (const { ekran, noktalar } of AKIS) {
  const bit = noktalar.reduce((t, [, n]) => t + log2(n + 1), 0);
  const sure = noktalar.reduce((t, [, n]) => t + esOlasiSure(n), 0);
  toplamBit += bit; toplamSure += sure; toplamNokta += noktalar.length;
  console.log(`${ekran.padEnd(16)} ${String(noktalar.length).padStart(13)} ${bit.toFixed(2).padStart(11)} ${(sure.toFixed(2) + " sn").padStart(13)}`);
}
console.log(`${"TOPLAM".padEnd(16)} ${String(toplamNokta).padStart(13)} ${toplamBit.toFixed(2).padStart(11)} ${(toplamSure.toFixed(2) + " sn").padStart(13)}`);

// 5) Karar yorgunlugu: harcanan bit arttikca hata olasiligi yukselir
// p_hata(x) = p0 + k * (x / butce)^2 ; x = o ana kadar harcanan bit
const P0 = 0.02, K = 0.16, BUTCE = 32;
function akisHatasi(akis) {
  let harcanan = 0, beklenenHata = 0;
  for (const { noktalar } of akis) {
    for (const [, n] of noktalar) {
      const bit = log2(n + 1);
      const p = Math.min(1, P0 + K * Math.pow(harcanan / BUTCE, 2));
      beklenenHata += p;
      harcanan += bit;
    }
  }
  return { harcanan, beklenenHata };
}
const once = akisHatasi(AKIS);
console.log(`\nharcanan bilgi ${once.harcanan.toFixed(2)} bit, beklenen hatali secim sayisi ${once.beklenenHata.toFixed(3)}`);

// 6) Azaltilmis akis: varsayilanlari olan alanlar karar noktasi olmaktan cikar
const AZALTILMIS = [
  { ekran: "arama", noktalar: [["arama alani", 1]] },
  { ekran: "sonuc listesi", noktalar: [["suzgec paneli (4 grup)", 4], ["grup ici secim", 6], ["kayit secimi", 20]] },
  { ekran: "kayit ayrinti", noktalar: [["odunc / rezerve / listeye ekle", 3]] },
  { ekran: "odunc onayi", noktalar: [["onay", 2]] },
];
const sonra = akisHatasi(AZALTILMIS);
const azSure = AZALTILMIS.reduce((t, e) => t + e.noktalar.reduce((s, [, n]) => s + esOlasiSure(n), 0), 0);
const azNokta = AZALTILMIS.reduce((t, e) => t + e.noktalar.length, 0);
console.log(`azaltilmis akis: ${azNokta} karar noktasi, ${sonra.harcanan.toFixed(2)} bit, ${azSure.toFixed(2)} sn, beklenen hatali secim ${sonra.beklenenHata.toFixed(3)}`);
console.log(`kazanc: ${(toplamNokta - azNokta)} karar noktasi, ${(toplamSure - azSure).toFixed(2)} sn, ${((1 - sonra.beklenenHata / once.beklenenHata) * 100).toFixed(1)} % daha az beklenen hata`);

secenek  bilgi (bit)  karar suresi
      2        1.585      0.438 sn
      4        2.322      0.548 sn
      8        3.170      0.675 sn
     12        3.700      0.755 sn
     16        4.087      0.813 sn
     24        4.644      0.897 sn
     32        5.044      0.957 sn

24 suzgec secenegi icin duzen karsilastirmasi
duz liste (24)          0.897 sn
4 grup x 6 secenek      1.169 sn   (fark 0.273 sn)
3 grup x 8 secenek      1.175 sn   (fark 0.279 sn)
2 grup x 12 secenek     1.193 sn   (fark 0.296 sn)

kullanim dagilimi es olasili olmadiginda (24 secenek)
es olasili dagilim      entropi 4.585 bit   sure 0.888 sn
gozlenen dagilim        entropi 2.967 bit   sure 0.645 sn
siklik sirasina koymanin kazanci: 0.243 sn
gruplamanin kazanci (es olasili varsayimiyla):  -0.273 sn

ekran            karar noktasi  toplam bit  karar suresi
arama                        3        5.58       1.44 sn
sonuc listesi                4       13.94       2.89 sn
kayit ayrinti                2        4.00       1.00 sn
odunc onayi                  4        8.71       2.11 sn
TOPLAM                      13       32.24       7.44 sn

harcanan bilgi 32.24 bit, beklenen hatali secim sayisi 0.943
azaltilmis akis: 6 karar noktasi, 14.11 bit, 3.32 sn, beklenen hatali secim 0.170
kazanc: 7 karar noktasi, 4.12 sn, 82.0 % daha az beklenen hata

Seçenek Eklemek Ucuzdur, Seçenek Kümesi Eklemek Pahalıdır

İlk tablo logaritmik artışın ne demek olduğunu gösteriyor. Seçenek sayısı ikiden otuz ikiye, yani on altı katına çıkarken karar süresi 0.438 saniyeden 0.957 saniyeye, yani yalnızca 2.2 katına çıkıyor. Sekiz seçenekten on altıya geçmenin bedeli 0.138 saniye.

Bu, tek bir açılır listeye seçenek eklemenin ucuz olduğu anlamına gelir. Pahalı olan başka bir şeydir ve dördüncü tabloda görünür: ayrı bir karar noktası eklemek. Her karar noktası $a$ sabitini yeniden ödetir. Üçüncü ekrandaki iki karar noktası 1.00 saniye tutuyor; bunun 0.40 saniyesi, yani yüzde 40’ı, seçeneklerin sayısından değil karar noktalarının sayısından geliyor.

Kural şudur: on iki seçenekli bir alan, üç seçenekli dört alandan daha ucuzdur. Hesap bunu doğruluyor — on iki seçenekli tek alan 0.755 saniye, üç seçenekli dört alan $4 \times 0.500 = 2.000$ saniye.

Gruplamanın Etkisi Beklenenin Tersidir

İkinci tablo, sık verilen bir tasarım öğüdüyle çelişiyor. Yirmi dört seçenekli düz liste 0.897 saniye; aynı yirmi dört seçenek dört gruba bölündüğünde 1.169 saniye. Gruplama karar süresini 0.273 saniye artırıyor, azaltmıyor. Nedeni önceki paragraftaki kuraldır: gruplama, tek bir karar noktasını iki karar noktasına çeviriyor ve $a$ sabiti iki kez ödeniyor.

Bu sonuç gruplamanın yanlış olduğu anlamına gelmez; gruplamanın karar süresi için yapılmadığı anlamına gelir. Gruplama başka bir maliyeti düşürür: kullanıcının aradığı seçeneği listede bulma maliyetini. Yirmi dört ögelik etiketsiz bir listede kullanıcı ögeleri okumak zorundadır; dört başlıklı bir listede yalnızca bir başlığın altını okur. Hick–Hyman bağıntısı seçeneğin zaten bilindiğini varsayar — arama maliyetini hesaba katmaz. İki maliyet ayrı ayrı ölçülür ve ayrı ayrı gerekçelendirilir.

Üçüncü tablo daha büyük bir kazanç gösteriyor. Süzgeç kullanımı eş olasılıklı değilse — kullanıcıların yüzde 77’si yalnızca üç ölçütü kullanıyorsa — entropi 4.585 bitten 2.967 bite düşüyor ve süre 0.888 saniyeden 0.645 saniyeye iniyor. Sık kullanılanı öne koymanın kazancı 0.243 saniye; gruplamanın “kazancı” ise eksi 0.273 saniye. Yük düşürmenin en verimli yolu seçenekleri yeniden düzenlemek değil, kullanım dağılımını arayüze yansıtmaktır.

Bunun bir önkoşulu var: kullanım dağılımının bilinmesi. Bu dağılım tahminle değil ölçümle elde edilir; ölçme konusunun konusudur.

Yorgunluk Yükün İkinci Faturasıdır

Beşinci hesap yükün süre dışında bir bedeli daha olduğunu modelliyor. Kullanıcının dikkati sınırlıdır ve harcandıkça hata olasılığı yükselir. Modelde hata olasılığı, o ana kadar harcanmış bit sayısının karesiyle artıyor.

Ödünç alma akışının tamamı on üç karar noktası ve 32.24 bit tutuyor. Bu yükte beklenen hatalı seçim sayısı 0.943 — akışı tamamlayan her kullanıcı ortalama bir kararı yanlış veriyor. Yanlış verilen karar akışın sonundaki bir karar olma eğilimindedir; en yorgun anlar en son ekrandadır. Katalog arayüzünde bu ekran ödünç onayıdır: teslim şubesi, süre ve hatırlatma tercihi burada seçilir. Yanlış şubeye ısmarlanan bir kitap, kullanıcının en pahalı hatasıdır.

Altıncı hesap yedi karar noktasını kaldırıyor. Kaldırılan alanlar yok olmuyor; varsayılan değer alıyorlar. Teslim şubesi kullanıcının bağlı olduğu şube, süre en uzun süre, hatırlatma tercihi açık geliyor. Kullanıcı isterse değiştirebiliyor ama değiştirmediği sürece karar vermek zorunda kalmıyor. Sonuç: 7.44 saniye yerine 3.32 saniye ve yüzde 82 daha az beklenen hata.

Buradan iki ayrı sonuç çıkar ve karıştırılmamalıdırlar. Birincisi bir tasarım kazancıdır: kullanıcıdan istenmeyen karar, verilmeyen karardan iyidir. İkincisi bir uyarıdır: varsayılan koymak, kararı kullanıcıdan alıp tasarımcıya vermektir. Yukarıdaki üç varsayılan kullanıcının yararınadır — kullanıcı bilseydi de aynısını seçerdi. Aynı mekanizma kullanıcının aleyhine kurulabilir. Varsayılanların gücü ve o gücün sınırı ayrı bir dersin konusudur.

Yükü Ölçmenin Pratik Yolu

Bir ekranın yükünü ölçmek için tasarım aracına gerek yok; sayım yeter.

Bağımsız karar noktalarını say. Kullanıcının değer atamak zorunda olduğu her alan bir noktadır. Değeri önceden dolu ve kullanıcı dokunmadan geçebiliyorsa nokta sayılmaz.

Her noktanın seçenek sayısını yaz ve $\log_2(n+1)$ topla. Toplam, ekranın bit cinsinden yüküdür. Ekranlar arasında karşılaştırma bu sayıyla yapılır.

Aynı akıştaki toplam biti izle. Yorgunluk akış boyunca birikir; tek tek makul görünen ekranlar toplandığında makul olmayabilir.

Sırayı kullanım dağılımına göre kur. Sıklık sırası, gruplamadan daha büyük bir kazanç verir ve karar noktası eklemez.

Özet

• Hick–Hyman bağıntısı karar süresini seçenek sayısının logaritmasına bağlar: $T = a + b \log_2(n+1)$; seçenek sayısını ikiye katlamak süreye bir bit ekler.
• Seçenek eklemek ucuz, karar noktası eklemek pahalıdır; on iki seçenekli tek alan, üç seçenekli dört alandan yaklaşık 2.6 kat hızlı seçilir.
• Gruplama karar süresini düşürmez, hesapta 0.273 saniye artırır; gruplamanın gerekçesi karar süresi değil, seçeneği listede bulma maliyetidir.
• Kullanım dağılımı eş olasılıklı olmadığında entropi düşer; süzgeçleri sıklık sırasına koymak 0.243 saniye kazandırır ve karar noktası eklemez.
• Yük akış boyunca birikir ve hata olasılığını yükseltir; on üç karar noktalı ödünç akışı altı noktaya indiğinde beklenen hatalı seçim yüzde 82 azalır.
• Varsayılan vermek kararı kullanıcıdan alıp tasarımcıya devretmektir; kazancı da riski de buradan gelir.

Sonraki Adım

Bu ders kullanıcının bir kararı ne kadar zor verdiğini ölçtü. Ölçmediği şey, kararı hiç vermemesi. Katalog kullanıcısı ödünç alma akışını tamamlamayabilir; yük düşük olsa bile başlamayabilir. Sonraki ders davranışın gerçekleşmesi için hangi üç koşulun aynı anda sağlanması gerektiğini kurar ve bu koşullardan hangisine müdahale etmenin daha çok kullanıcıyı akışa soktuğunu hesaplar.