---
title: 'Kullanılabilirlik Testi'
source: 'https://academia.sh/tr/kurslar/kullanici-deneyimi/kullanilabilirlik-testi'
course: 'Kullanıcı Deneyimi ve Davranış Tasarımı'
language: tr
updated: '2026-08-17T18:09:38+00:00'
license: 'CC BY-SA 4.0'
---

# Kullanılabilirlik Testi

Küçük örneklemle sorun bulma; keşif eğrisinin hesaplanması, beş katılımcı savının tekdüze olmayan sorun kümesinde niçin çöktüğü ve küçük örneklemde süre ölçümünün belirsizliği.

Sezgi değerlendirmesi on iki aday üretti ve her biri bir varsayım. Hangilerinin gerçek
kullanıcıyı gerçekten durdurduğu, hangilerinin hiç fark edilmediği ölçülmeden bilinemez.
Bunu ölçmenin yolu prototipi bir katılımcının eline vermek ve bir görev vermektir.

**Kullanılabilirlik testi (usability test)**, katılımcının önceden belirlenmiş bir görevi
yapmaya çalışırken gözlenmesidir. Amacı görüş toplamak değildir; kullanıcının nerede
durakladığı, nereye tıkladığı ve nerede vazgeçtiği ölçülür. Bu ders oturumun nasıl
kurulduğunu, kaç katılımcı gerektiğini ve küçük örneklemin neyi söyleyip neyi
söyleyemediğini hesapla ele alır.

## Oturumun Kurulması

Oturum üç parçadan oluşur ve her parçanın kendi kuralı vardır.

**Görev senaryosu.** Katılımcıya yapılacak iş bir bağlamla verilir, bir yönergeyle değil.
"Ödünç al düğmesine basın" bir yönergedir ve hiçbir şey ölçmez. "Bir arkadaşınız size bir
kitap önerdi; kütüphanede var mı, varsa nasıl alacağınızı bulun" bir senaryodur; kullanıcının
yolu kendi bulmasını gerektirir. Senaryo, arayüzün sözcüklerini kullanmaz — "daraltma"
sözcüğü senaryoda geçerse, o sözcüğün anlaşılıp anlaşılmadığı ölçülemez.

**Sesli düşünme.** Katılımcıdan ne yaptığını ve ne beklediğini sesli söylemesi istenir. Bu,
gözlemin göremediğini açığa çıkarır: kullanıcının bir ögeyi görüp de anlamadığını, ya da
ekranda olmayan bir şeyi aradığını yalnızca sözünden anlarız. Sesli düşünme süreyi uzatır;
bu yüzden süre ölçülecekse ayrı bir görev sessiz yaptırılır.

**Moderatörün yapmadıkları.** Moderatör yol göstermez, ipucu vermez, "orada" demez.
Katılımcı takıldığında beklenir; gerçekten durduğunda görev sonlandırılır ve bu bir bulgudur.
Moderatör ayrıca savunma yapmaz: "aslında oraya koymuştuk" cümlesi katılımcıyı susturur ve
oturumun geri kalanını değersizleştirir.

## Testin Etik Çerçevesi

Kullanılabilirlik testi, katılımcının başarısız olmasının veri sayıldığı bir oturumdur; bu
onu etik açıdan araştırmanın en dikkat isteyen biçimlerinden biri yapar.

**Sınanan arayüzdür, katılımcı değildir.** Bu cümle oturumun başında açıkça söylenir ve
sözde kalmaz: görev tamamlanamadığında katılımcıya bunun arayüzün bulgusu olduğu hatırlatılır.
Katılımcının kendini sınanıyor hissetmesi hem etik bir sorundur hem de veriyi bozar.

**Onay ayrıntılıdır ve geri alınabilir.** Katılımcı neyin kaydedildiğini — ekran, ses,
tıklama izi — ve kaydın kimlerce görüleceğini bilerek onay verir. Oturumu istediği an
durdurabilir ve bunu gerekçelendirmesi gerekmez. Oturum sonunda kaydının silinmesini isterse
silinir.

**Kimliksizleştirme ve saklama sınırı.** Bulgular `K01` gibi kodlarla yazılır. Ekran
kaydında katılımcının hesabı görünüyorsa gerçek üyelik yerine sınama hesabı kullanılır;
kullanılamıyorsa kayıttaki tanımlayıcı alanlar çözümleme öncesinde temizlenir. Ham kayıt
kodlanmış nota dönüştürüldükten sonra, yazılı saklama süresi içinde silinir.

**Alıntı kullanımı ayrı bir onaydır.** Katılımcının sözünü rapora almak, kaydını
çözümlemekten farklı bir kullanımdır. Doğrudan alıntı yapılacaksa bu ayrıca sorulur.

## Beş Katılımcı Savı

Küçük örneklemi savunan yaygın bir hesap vardır. Bir sorunun tek bir katılımcıda ortaya
çıkma olasılığı `p` ise, `n` katılımcıda en az bir kez görülme olasılığı `1 - (1 - p)^n`
olur. Bu eğri hızlı doyar ve beş katılımcının çoğu sorunu bulmaya yettiği sonucuna götürür.
Hesabın kendisi doğru; taşıdığı varsayım sorunludur.

```js
// kesif-egrisi.mjs — 1 - (1 - p)^n egrisi ve tekduze olmayan bulunma olasiliklari

// Tekduze varsayim: her sorun her katilimcida ayni olasilikla ortaya cikiyor
console.log("tekduze p ile bulunan sorun orani");
console.log("katilimci  p=0.10  p=0.20  p=0.31  p=0.50");
for (const n of [1, 2, 3, 5, 8, 10, 15, 20]) {
  const s = [0.1, 0.2, 0.31, 0.5].map((p) => ((1 - (1 - p) ** n) * 100).toFixed(1).padStart(6));
  console.log(`${String(n).padStart(9)}  ${s.join("  ")}`);
}

// Gercek sorun kumesi tekduze degildir: bazi sorunlar herkeste, bazilari nadiren cikar
const SORUNLAR = [
  { ad: "geri donuste arama kayip", p: 0.90, siddet: 4 },
  { ad: "raf kodu anlasilmiyor", p: 0.75, siddet: 3 },
  { ad: "es adli kayit karisiyor", p: 0.60, siddet: 3 },
  { ad: "yukleme durumu yok", p: 0.50, siddet: 2 },
  { ad: "ayni eylem farkli adlarla", p: 0.40, siddet: 3 },
  { ad: "yer tutucu etiket yerine", p: 0.30, siddet: 3 },
  { ad: "uc eylem esit agirlikta", p: 0.25, siddet: 2 },
  { ad: "hata iletisi nedensiz", p: 0.20, siddet: 3 },
  { ad: "uzatma yolu gizli", p: 0.15, siddet: 3 },
  { ad: "yardim derinde", p: 0.10, siddet: 1 },
  { ad: "kisayol yok", p: 0.08, siddet: 2 },
  { ad: "ucret onaylatilmiyor", p: 0.05, siddet: 4 },
];
const ortP = SORUNLAR.reduce((t, s) => t + s.p, 0) / SORUNLAR.length;
console.log(`\nsorun kumesinin ortalama p degeri: ${ortP.toFixed(4)}`);

console.log("\nkatilimci  tekduze p ile  gercek kume  siddetle agirlikli  bulunma olasiligi en dusuk sorun");
const siddetToplam = SORUNLAR.reduce((t, s) => t + s.siddet, 0);
for (const n of [1, 3, 5, 8, 12, 20, 32]) {
  const tekduze = (1 - (1 - ortP) ** n) * 100;
  const gercek = (SORUNLAR.reduce((t, s) => t + (1 - (1 - s.p) ** n), 0) / SORUNLAR.length) * 100;
  const agirlikli = (SORUNLAR.reduce((t, s) => t + s.siddet * (1 - (1 - s.p) ** n), 0) / siddetToplam) * 100;
  const enDusuk = Math.min(...SORUNLAR.map((s) => 1 - (1 - s.p) ** n)) * 100;
  console.log(
    `${String(n).padStart(9)}  ${tekduze.toFixed(1).padStart(12)}%  ${gercek.toFixed(1).padStart(10)}%  ${agirlikli.toFixed(1).padStart(17)}%  ${enDusuk.toFixed(1).padStart(30)}%`
  );
}

// Her sorunun 5 katilimcida bulunma olasiligi
console.log("\nsorun                       p     siddet  5 katilimcida bulunma");
for (const s of SORUNLAR) {
  const b = (1 - (1 - s.p) ** 5) * 100;
  console.log(`${s.ad.padEnd(26)} ${s.p.toFixed(2)}  ${String(s.siddet).padStart(6)}  ${b.toFixed(1).padStart(20)}%`);
}

// Her sorunun en az %80 olasilikla bulunmasi icin kac katilimci gerekir
const enNadir = SORUNLAR.reduce((a, b) => (a.p < b.p ? a : b));
const gerekli = Math.ceil(Math.log(0.2) / Math.log(1 - enNadir.p));
console.log(`\nen nadir sorun "${enNadir.ad}" (p = ${enNadir.p}) icin %80 bulma olasiligi: ${gerekli} katilimci`);
```

```
tekduze p ile bulunan sorun orani
katilimci  p=0.10  p=0.20  p=0.31  p=0.50
        1    10.0    20.0    31.0    50.0
        2    19.0    36.0    52.4    75.0
        3    27.1    48.8    67.1    87.5
        5    41.0    67.2    84.4    96.9
        8    57.0    83.2    94.9    99.6
       10    65.1    89.3    97.6    99.9
       15    79.4    96.5    99.6   100.0
       20    87.8    98.8    99.9   100.0

sorun kumesinin ortalama p degeri: 0.3567

katilimci  tekduze p ile  gercek kume  siddetle agirlikli  bulunma olasiligi en dusuk sorun
        1          35.7%        35.7%               38.7%                             5.0%
        3          73.4%        61.0%               63.3%                            14.3%
        5          89.0%        72.3%               73.9%                            22.6%
        8          97.1%        81.4%               82.2%                            33.7%
       12          99.5%        87.9%               88.1%                            46.0%
       20         100.0%        94.0%               93.7%                            64.2%
       32         100.0%        97.5%               97.1%                            80.6%

sorun                       p     siddet  5 katilimcida bulunma
geri donuste arama kayip   0.90       4                 100.0%
raf kodu anlasilmiyor      0.75       3                  99.9%
es adli kayit karisiyor    0.60       3                  99.0%
yukleme durumu yok         0.50       2                  96.9%
ayni eylem farkli adlarla  0.40       3                  92.2%
yer tutucu etiket yerine   0.30       3                  83.2%
uc eylem esit agirlikta    0.25       2                  76.3%
hata iletisi nedensiz      0.20       3                  67.2%
uzatma yolu gizli          0.15       3                  55.6%
yardim derinde             0.10       1                  41.0%
kisayol yok                0.08       2                  34.1%
ucret onaylatilmiyor       0.05       4                  22.6%

en nadir sorun "ucret onaylatilmiyor" (p = 0.05) icin %80 bulma olasiligi: 32 katilimci
```

## Eğrinin Okunması

**Tekdüze varsayım savı ayakta tutuyor.** Bütün sorunların aynı `p` değerine sahip olduğu
varsayılırsa, `p = 0.31` için beş katılımcı sorunların %84.4'ünü buluyor. Bu hesap doğru
yapılmış ve sonuç iç tutarlıdır.

**Gerçek sorun kümesi tekdüze değildir.** Örnek kümenin ortalama `p` değeri 0.3567; tekdüze
kabul edilirse beş katılımcıda beklenen kapsama %89.0. Aynı ortalamayı taşıyan ama dağılımı
geniş olan gerçek kümede beklenen kapsama %72.3. Aradaki 16.7 puanlık fark tümüyle
dağılımdan geliyor: yüksek `p` değerli sorunlar zaten birinci katılımcıda çıkıyor ve
eğriyi yukarı çekiyor, düşük `p` değerli sorunlar ise katılımcı eklendikçe çok yavaş
yaklaşıyor. Ortalamanın üzerinden yapılan hesap, kolay bulunanları fazladan sayar.

**Kaçırılan sorun rastgele seçilmez.** Son tablo sorunları bulunma olasılığına göre
sıralıyor ve listenin en altında şiddeti 4 olan bir sorun var: ücretin önce onaylatılmaması.
Beş katılımcıda bulunma olasılığı %22.6. Bu, önceki derste sezgi değerlendirmesinde de
yalnızca bir kişinin bulduğu sorundu. İki yöntem de aynı sorunu aynı nedenle kaçırıyor:
**nadir görülen ve ağır sonuç doğuran sorunlar, sıklığa dayanan hiçbir yöntemle güvenilir
biçimde bulunamaz.** Bunlar akış diyagramı denetimi ve ölçüt taraması gibi yapısal
yöntemlerle aranır.

**Şiddetle ağırlıklandırmak tabloyu kurtarmıyor.** Ağırlıklı kapsama beş katılımcıda %73.9;
ağırlıksız kapsamaya çok yakın. Ağır sorunların bir bölümü sık, bir bölümü nadir olduğu için
ağırlıklandırma dengeleniyor. Ağır sorunların özellikle nadir olduğu bir arayüzde ağırlıklı
kapsama ağırlıksızın altına düşer.

**Her sorunu bulmak pahalıdır.** En nadir sorunun %80 olasılıkla bulunması için otuz iki
katılımcı gerekiyor. Bu sayı çoğu koşulda karşılanamaz ve karşılanması da gerekmez. Doğru
sonuç şudur: küçük örneklemli test **sık sorunları ucuza bulan** bir yöntemdir ve bulunanları
düzeltmeye yarar; bulunmayanların yokluğunu kanıtlamaz. "Beş kullanıcıyla test ettik, sorun
çıkmadı" cümlesi bir kanıt değildir.

Uygulamada bunun karşılığı, testi tek bir büyük oturum yerine **art arda küçük turlar** hâlinde
yürütmektir: beş katılımcı, düzeltme, yeni beş katılımcı. Her turda en sık sorunlar
temizlendiği için bir sonraki turda daha seyrek sorunlar görünür hâle gelir.

## Küçük Örneklemde Süre Ölçmenin Sınırı

Testin ikinci çıktısı süre ölçümüdür ve burada küçük örneklemin sınırı daha serttir.

```js
// sure-olcumu.mjs — kucuk orneklemde ortanca sure ve belirsizligi

// Bes katilimcinin "bilinen kaydi bul ve odunc al" gorevindeki ekran suresi (saniye)
const SURE = [42, 55, 61, 78, 154];

const sirali = [...SURE].sort((a, b) => a - b);
const ortalama = SURE.reduce((a, b) => a + b, 0) / SURE.length;
const ortanca = sirali[(sirali.length - 1) / 2];
const geometrik = Math.exp(SURE.reduce((t, x) => t + Math.log(x), 0) / SURE.length);

console.log(`olculen sureler    : ${sirali.join(", ")} sn`);
console.log(`aritmetik ortalama : ${ortalama.toFixed(1)} sn`);
console.log(`geometrik ortalama : ${geometrik.toFixed(1)} sn`);
console.log(`ortanca            : ${ortanca.toFixed(1)} sn`);
console.log(`ortalama / ortanca : ${(ortalama / ortanca).toFixed(2)}`);
const engenis = Math.max(...SURE);
console.log(`en buyuk deger (${engenis} sn) cikarilirsa ortalama: ${(SURE.filter((x) => x !== engenis).reduce((a, b) => a + b, 0) / 4).toFixed(1)} sn`);

// Siralama istatistikleriyle ortanca icin dagilimdan bagimsiz guven araligi
const binom = (n, k) => {
  let r = 1;
  for (let i = 0; i < k; i++) r = (r * (n - i)) / (i + 1);
  return r;
};
const kapsama = (n, i, j) => {
  let t = 0;
  for (let k = i; k < j; k++) t += binom(n, k);
  return t / 2 ** n;
};

console.log("\nn = 5 icin siralama araliklarinin ortancayi kapsama olasiligi");
for (const [i, j] of [[1, 5], [2, 4]]) {
  console.log(
    `  [${i}. deger, ${j}. deger] = [${sirali[i - 1]}, ${sirali[j - 1]}] sn  ->  ${(kapsama(5, i, j) * 100).toFixed(2)}%`
  );
}

// En az %90 kapsama veren en dar siralama araligi
const enDarAralik = (n) => {
  for (let g = 1; g < n; g++)
    for (let i = 1; i + g <= n; i++)
      if (kapsama(n, i, i + g) >= 0.9) return [i, i + g, g, kapsama(n, i, i + g)];
  return null;
};
console.log("\nkatilimci  %90 kapsayan en dar aralik  kapsanan sira  orneklemin payi");
for (const n of [5, 8, 12, 20, 30, 50]) {
  const a = enDarAralik(n);
  console.log(
    `${String(n).padStart(9)}  ${`[${a[0]}. , ${a[1]}. ]`.padStart(24)}  ${String(a[2] + 1).padStart(13)}  ${(((a[2] + 1) / n) * 100).toFixed(1).padStart(15)}%`
  );
}
```

```
olculen sureler    : 42, 55, 61, 78, 154 sn
aritmetik ortalama : 78.0 sn
geometrik ortalama : 70.1 sn
ortanca            : 61.0 sn
ortalama / ortanca : 1.28
en buyuk deger (154 sn) cikarilirsa ortalama: 59.0 sn

n = 5 icin siralama araliklarinin ortancayi kapsama olasiligi
  [1. deger, 5. deger] = [42, 154] sn  ->  93.75%
  [2. deger, 4. deger] = [55, 78] sn  ->  62.50%

katilimci  %90 kapsayan en dar aralik  kapsanan sira  orneklemin payi
        5                [1. , 5. ]              5            100.0%
        8                [2. , 7. ]              6             75.0%
       12                [3. , 9. ]              7             58.3%
       20               [6. , 14. ]              9             45.0%
       30              [11. , 20. ]             10             33.3%
       50              [19. , 31. ]             13             26.0%
```

Görev süreleri sağa çarpıktır: alt sınır görevin fiziksel olarak yapılabileceği süredir, üst
sınır yoktur. Bir katılımcı takılıp 154 saniye harcadığında aritmetik ortalama 78 saniyeye
çıkıyor; bu değer beş katılımcının dördünden büyüktür ve hiçbirini temsil etmez. O tek değer
çıkarıldığında ortalama 59 saniyeye iniyor. Ortanca 61 saniye ve tek bir uç değerden
etkilenmiyor. Süre ölçütü olarak ortanca kullanılır.

İkinci tablo asıl uyarıyı veriyor. Beş katılımcıyla, gerçek ortancayı %93.75 olasılıkla
kapsayan aralık örneklemin **tamamıdır**: 42 ile 154 saniye arası. Daha dar bir aralık —
55 ile 78 saniye — yalnızca %62.5 kapsıyor. Beş katılımcıdan çıkan 61 saniyelik ortanca bir
ölçüm değil, çok geniş bir aralığın orta noktasıdır.

Son tablo bunun nasıl daraldığını gösteriyor. Otuz katılımcıda %90 kapsayan aralık, sıralı
değerlerin ortadaki onunu kaplıyor — örneklemin üçte biri; elli katılımcıda dörtte biri.
Süre karşılaştırması yapılacaksa gereken örneklem, sorun bulmak için gerekenden bir
büyüklük basamağı fazladır.

Bunun uygulamadaki karşılığı sert bir ayrımdır: **küçük örneklemli test sorun bulur, sayı
üretmez.** Beş katılımcılı bir oturumdan "görev süresi 61 saniye" cümlesi çıkarılmaz;
"beş katılımcının dördü bir dakikanın altında tamamladı, biri raf kodunu arayarak takıldı"
cümlesi çıkarılır. İkincisi hem doğrudur hem karar ürettirir.

## Özet

- Kullanılabilirlik testi görüş toplamaz; görev senaryosu verilir, sesli düşünme istenir ve
  moderatör yol göstermez, savunma yapmaz.
- Sınanan arayüzdür; onay ayrıntılı ve geri alınabilirdir, bulgular kodla yazılır, ham kayıt
  saklama sınırı içinde silinir ve alıntı kullanımı ayrıca sorulur.
- Keşif eğrisi tekdüze bulunma olasılığı varsayar; örnek kümede aynı ortalamayla tekdüze
  hesap beş katılımcıda %89.0, gerçek dağılım %72.3 verdi.
- Kaçırılan sorunlar rastgele değildir: nadir ve ağır sorunlar sıklığa dayanan yöntemlerle
  bulunamaz, yapısal denetimlerle aranır; örnek kümenin en ağır sorunlarından biri beş
  katılımcıda ancak %22.6 olasılıkla görünüyor.
- Küçük örneklemli test sık sorunları ucuza bulur ve art arda turlarla yürütülür; bulgu
  çıkmaması sorun olmadığını kanıtlamaz.
- Süre ölçütü ortancadır; beş katılımcıda gerçek ortancayı %93.75 kapsayan aralık örneklemin
  tamamıdır, dolayısıyla küçük örneklemli test sorun bulur, sayı üretmez.

## Sonraki Adım

Test, kullanıcının nerede takıldığını gösteriyor. Raf kodunu arayarak takılan katılımcının
ekranda o bilgiye baktığı ama kullanmadığı görülüyor; eş adlı iki cilt arasında yanlış olanı
seçen katılımcının başlığın tamamını okumadığı görülüyor. Gözlem her ikisini de kaydediyor
ama hiçbirini açıklamıyor. Kullanıcı niçin baktığı bilgiyi kullanmadı, niçin okumadan seçti?
Bunlar dikkatsizlik değildir; kararın nasıl verildiğine ilişkin sorulardır. Sonraki konunun
ilk dersi olan Çift Süreçli Düşünme, kararların hızlı ve sezgisel bir süreçle mi yoksa yavaş
ve düşünsel bir süreçle mi alındığını ayırır ve arayüzün hangisine hitap ettiğini sorar.
