Dersler ve Temeller; web örnekleri PORT ortam değişkenini okur

- dersler/: 29 kısa ders (açıklama, çalıştırılabilir örnek, alıştırma). Her örneğin
  ve alıştırma çözümünün çıktısı Online IDE'nin hazırlık adımında gerçekten koşulup
  dosyadakiyle karşılaştırılır; biçim dersler/BICIM.md.
- temeller/: tek konulu 12 başlangıç programı.
- web/anket, web/kisalt, web/pano: port PORT ortam değişkeninden okunur (Online IDE
  önizlemesi 8080 verir), yoksa eski sabit port.
- README: öğrenme bölümü, Online IDE bağlantısı.

dersler/01-kabalang-giris.md

@@ -0,0 +1,107 @@
+---
+baslik: KabaLang'a giriş
+bolum: Giriş
+ozet: İlk programın, yazdir ve örnekleri IDE'de çalıştırmak
+---
+
+KabaLang, anahtar sözcükleri Türkçe olan bir programlama dilidir. `eger`, `dongu`, `fonksiyon` gibi sözcüklerle yazarsın; derleyici programını hızlı çalışan bir makine koduna çevirir.
+
+Bu derslerde her konuyu küçük örneklerle öğreneceksin. Her örneğin altında programın gerçek çıktısı var. **Dene** düğmesine basınca örnek düzenleyicide açılır; değiştirip yeniden çalıştırabilirsin.
+
+## İlk programın
+
+Ekrana bir şey yazdırmak için `yazdir(...)` kullanılır. Parantez içindeki metin ekrana basılır ve satır biter.
+
+```kbl
+yazdir("Merhaba, dünya!")
+```
+```cikti
+Merhaba, dünya!
+```
+
+Metinler çift tırnak arasına yazılır. Türkçe harfler olduğu gibi çalışır.
+
+## Birden çok satır
+
+Program yukarıdan aşağıya, satır satır çalışır. Her `yazdir` yeni bir satıra yazar.
+
+```kbl
+yazdir("Günaydın İstanbul!")
+yazdir("Bugün hava güneşli.")
+yazdir("Çay demlendi.")
+```
+```cikti
+Günaydın İstanbul!
+Bugün hava güneşli.
+Çay demlendi.
+```
+
+## Sayı yazdırmak ve hesap yapmak
+
+`yazdir` yalnız metin değil, sayı da yazar. Parantez içine bir hesap koyarsan önce hesaplanır, sonra sonucu yazılır.
+
+```kbl
+yazdir(42)
+yazdir(7 * 6)
+yazdir(100 - 58)
+```
+```cikti
+42
+42
+42
+```
+
+## Virgülle birden çok değer
+
+`yazdir`'a virgülle ayırarak birden çok değer verebilirsin. Aralarına birer boşluk konur.
+
+```kbl
+yazdir("Bir yılda", 12, "ay var.")
+yazdir("Bir günde", 24 * 60, "dakika var.")
+```
+```cikti
+Bir yılda 12 ay var.
+Bir günde 1440 dakika var.
+```
+
+Boş bir `yazdir()` araya boş bir satır koyar.
+
+```kbl
+yazdir("Birinci bölüm")
+yazdir()
+yazdir("İkinci bölüm")
+```
+```cikti
+Birinci bölüm
+
+İkinci bölüm
+```
+
+> **Dikkat:** `yazdir` küçük harfle yazılır. `Yazdir("x")` yazarsan derleyici "'Yazdir' adında bir değişken veya fonksiyon tanımlanmamış" der. KabaLang büyük ve küçük harfi ayırır.
+
+> **İpucu:** Örnekleri yalnız okuma; **Dene**'ye basıp metni değiştir, kendi adını yazdır. En hızlı böyle öğrenirsin.
+
+## Alıştırma
+
+```alistirma
+Ekrana iki satır yazdır: önce `Merhaba KabaLang`, sonra `Programlamaya başladım.`
+%%%
+yazdir("Merhaba KabaLang")
+# buraya yaz
+%%%
+yazdir("Merhaba KabaLang")
+yazdir("Programlamaya başladım.")
+%%%
+Merhaba KabaLang
+Programlamaya başladım.
+```
+
+```alistirma
+Bir haftada kaç saat olduğunu hesaplatıp `Bir haftada 168 saat var.` biçiminde yazdır. Sayıyı kendin yazma, `7 * 24` hesabını kullan.
+%%%
+# buraya yaz
+%%%
+yazdir("Bir haftada", 7 * 24, "saat var.")
+%%%
+Bir haftada 168 saat var.
+```

dersler/02-sozdizimi-girinti.md

@@ -0,0 +1,118 @@
+---
+baslik: Sözdizimi ve girinti
+bolum: Giriş
+ozet: Satırlar, iki nokta, girintili bloklar ve büyük/küçük harf
+---
+
+Her dilin bir yazım kuralı vardır. KabaLang'de kurallar az ve sade: her komut kendi satırında durur, bloklar süslü parantezle değil **girintiyle** belirtilir.
+
+## Her satır bir komut
+
+Satır sonuna noktalı virgül koymazsın. Satır bitince komut da biter.
+
+```kbl
+yazdir("Ankara")
+yazdir("İzmir")
+```
+```cikti
+Ankara
+İzmir
+```
+
+## Bloklar: iki nokta ve girinti
+
+Bazı satırlar bir **blok** açar: `eger`, `dongu`, `fonksiyon` gibi. Bu satırlar `:` ile biter. Altındaki satırlar 4 boşluk içeriden başlar; o satırlar bloğa aittir.
+
+```kbl
+sicaklik = 32
+eger sicaklik > 30:
+    yazdir("Hava çok sıcak.")
+    yazdir("Bol su iç.")
+yazdir("Bu satır her zaman çalışır.")
+```
+```cikti
+Hava çok sıcak.
+Bol su iç.
+Bu satır her zaman çalışır.
+```
+
+Girintisi biten satır, bloğun dışına çıkmış olur. Yukarıdaki son satır `eger`'e bağlı değildir.
+
+Sıcaklığı 20 yapıp **Dene** ile çalıştır: ilk iki satır kaybolur, son satır yine görünür.
+
+## İç içe bloklar
+
+Bir bloğun içinde başka bir blok açabilirsin. Her düzey 4 boşluk daha içeride başlar.
+
+```kbl
+sicaklik = 32
+yagmur = yanlis
+eger sicaklik > 25:
+    yazdir("Hava sıcak.")
+    eger degil yagmur:
+        yazdir("Pikniğe gidebilirsin.")
+```
+```cikti
+Hava sıcak.
+Pikniğe gidebilirsin.
+```
+
+> **Dikkat:** `:`'dan sonraki satırı girintisiz yazmak hatadır. Aşağıdaki kod derlenmez; derleyici "blok gövdesi boş — ':' sonrasındaki satırlar girintili olmalı" der.
+
+```kbl goster
+eger dogru:
+yazdir("girinti unutuldu")
+```
+
+Sebepsiz girinti de hatadır: blok açmayan bir satırın altını içeriden başlatamazsın. Bir de `:`'yı unutursan derleyici "':' bekleniyordu" der.
+
+## Büyük ve küçük harf
+
+KabaLang büyük/küçük harfi ayırır. `sehir`, `Sehir` ve `SEHIR` üç ayrı addır. Anahtar sözcükler (`eger`, `dongu`, `dogru`) ve hazır fonksiyonlar (`yazdir`) hep küçük harfle yazılır.
+
+```kbl
+sehir = "Bursa"
+Sehir = "Konya"
+yazdir(sehir)
+yazdir(Sehir)
+```
+```cikti
+Bursa
+Konya
+```
+
+> **İpucu:** Kodda Türkçe karakterli ad kullanmak yerine ASCII harfler yeğle: `sehir`, `ogrenci`, `dogru`. Anahtar sözcükler de böyle yazılır (`degilse`, `iken`). Metinlerin içinde ise ç, ğ, ı, ö, ş, ü'yü serbestçe kullan.
+
+## Uzun satırı bölmek
+
+Parantez açıkken satırı bölebilirsin; parantez kapanana kadar tek satır sayılır.
+
+```kbl
+toplam = (120 +
+    75 +
+    300)
+yazdir(toplam)
+```
+```cikti
+495
+```
+
+## Alıştırma
+
+```alistirma
+`puan` 50'den büyükse önce `Geçtin.` sonra `Tebrikler!` yazdır. Bu iki satır bloğun içinde olsun. En sonda, bloğun dışında `Sınav bitti.` yazdır.
+%%%
+puan = 72
+eger puan > 50:
+    # buraya yaz
+%%%
+puan = 72
+eger puan > 50:
+    yazdir("Geçtin.")
+    yazdir("Tebrikler!")
+yazdir("Sınav bitti.")
+%%%
+Geçtin.
+Tebrikler!
+Sınav bitti.
+```

dersler/03-yorumlar.md

@@ -0,0 +1,94 @@
+---
+baslik: Yorumlar
+bolum: Giriş
+ozet: Kodun içine kendine ve başkalarına not bırakmak
+---
+
+Yorum, derleyicinin okumadığı, yalnız insanlar için yazılmış nottur. Bir hafta sonra kendi koduna baktığında "bunu neden yazmıştım?" diye sormamak için yorum yazarsın.
+
+## Tek satırlık yorum
+
+`#` işaretinden sonra satırın sonuna kadar her şey yorumdur.
+
+```kbl
+# Bu program bir selam yazar.
+yazdir("Merhaba!")
+```
+```cikti
+Merhaba!
+```
+
+## Satır sonunda yorum
+
+Kodun yanına da yorum yazabilirsin. `#`'den öncesi çalışır, sonrası yok sayılır.
+
+```kbl
+fiyat = 250        # TL cinsinden
+adet = 3           # sepetteki ürün sayısı
+yazdir(fiyat * adet)
+```
+```cikti
+750
+```
+
+## Kodu geçici olarak kapatmak
+
+Bir satırın başına `#` koyarsan o satır çalışmaz. Silmeden denemek için çok işe yarar.
+
+```kbl
+yazdir("Birinci satır")
+# yazdir("Bu satır şimdilik kapalı")
+yazdir("Üçüncü satır")
+```
+```cikti
+Birinci satır
+Üçüncü satır
+```
+
+## Metnin içindeki # yorum değildir
+
+Tırnak içindeki `#` sıradan bir karakterdir.
+
+```kbl
+yazdir("Sıra numaran: #12")   # bu kısım ise yorum
+```
+```cikti
+Sıra numaran: #12
+```
+
+> **İpucu:** İyi yorum kodun *ne* yaptığını değil *neden* yaptığını anlatır. `x = x + 1  # x'i bir artır` gereksizdir; `misafir += 1  # kapıdaki kişiyi de sayıyoruz` işe yarar.
+
+## Birden çok satırlık açıklama
+
+Uzun bir açıklama için her satırın başına `#` koyarsın.
+
+```kbl
+# Kargo ücreti hesabı:
+#   500 TL ve üstü siparişte kargo ücretsiz,
+#   altında 60 TL.
+sepet = 420
+kargo = 60
+eger sepet >= 500:
+    kargo = 0
+yazdir("Kargo:", kargo, "TL")
+```
+```cikti
+Kargo: 60 TL
+```
+
+## Alıştırma
+
+```alistirma
+Aşağıdaki programda ikinci satır hatalı bir duyuru yazıyor. O satırı **silmeden**, başına `#` koyarak kapat. Çıktıda yalnız iki doğru satır kalsın.
+%%%
+yazdir("Kütüphane 09:00'da açılır.")
+yazdir("Kütüphane pazar günü de açıktır.")
+yazdir("Kütüphane 18:00'de kapanır.")
+%%%
+yazdir("Kütüphane 09:00'da açılır.")
+# yazdir("Kütüphane pazar günü de açıktır.")
+yazdir("Kütüphane 18:00'de kapanır.")
+%%%
+Kütüphane 09:00'da açılır.
+Kütüphane 18:00'de kapanır.
+```

dersler/04-degiskenler.md

@@ -0,0 +1,156 @@
+---
+baslik: Değişkenler
+bolum: Temeller
+ozet: Değerlere ad vermek, yeniden atamak ve değişmezler
+---
+
+Program çalışırken bilgileri bir yerde tutman gerekir: bir öğrencinin adı, sepetteki ürün sayısı, bugünkü sıcaklık. Değişken, bir değere verdiğin addır.
+
+## Değişken oluşturmak
+
+`ad = değer` yazınca değer o ada bağlanır. Sonra o adı her kullandığında değeri gelir.
+
+```kbl
+ogrenci = "Elif"
+yas = 15
+yazdir(ogrenci)
+yazdir(yas)
+```
+```cikti
+Elif
+15
+```
+
+Türü yazmana gerek yoktur; KabaLang değere bakıp anlar. `"Elif"` bir metin, `15` bir tam sayıdır.
+
+## Değeri değiştirmek
+
+Bir değişkene yeni değer atayınca eskisi unutulur.
+
+```kbl
+sicaklik = 18
+yazdir(sicaklik)
+sicaklik = 24
+yazdir(sicaklik)
+```
+```cikti
+18
+24
+```
+
+Değişkenin yeni değerini eskisinden de hesaplayabilirsin.
+
+```kbl
+bakiye = 500
+bakiye = bakiye - 120
+bakiye = bakiye + 75
+yazdir(bakiye)
+```
+```cikti
+455
+```
+
+## Kısaltmalar: += ve -=
+
+`bakiye = bakiye + 75` yerine `bakiye += 75` yazabilirsin. `-=` ve `*=` de aynı mantıkla çalışır.
+
+```kbl
+puan = 10
+puan += 5      # puan = puan + 5
+puan *= 2      # puan = puan * 2
+puan -= 4      # puan = puan - 4
+yazdir(puan)
+```
+```cikti
+26
+```
+
+## Değişken adları
+
+- Harfle ya da `_` ile başlar; içinde harf, rakam ve `_` olabilir.
+- Boşluk içeremez: `dogum yili` olmaz, `dogum_yili` olur.
+- Anahtar sözcükler ad olamaz: `eger`, `dongu`, `sinif` gibi.
+- Anlamlı ad seç: `x` yerine `fiyat`, `n` yerine `ogrenci_sayisi`.
+
+```kbl
+dogum_yili = 2010
+bu_yil = 2026
+yazdir(bu_yil - dogum_yili)
+```
+```cikti
+16
+```
+
+## Bir değişkenin türü sabittir
+
+Bir değişkene ilk verdiğin değerin türü onun türü olur. Sonra başka türde bir değer atayamazsın.
+
+```kbl goster
+adet = 5
+adet = "beş"     # derleme hatası: metin, sayı türündeki değişkene atanamaz
+```
+
+> **Dikkat:** Program derlenmeden önce bu hata yakalanır. Farklı türde bir değer saklamak istiyorsan yeni bir ad kullan: `adet_yazi = "beş"`.
+
+## Aynı anda birden çok değişken
+
+Virgülle ayırarak birkaç değişkeni tek satırda oluşturabilirsin.
+
+```kbl
+ad, sehir = "Mert", "Trabzon"
+yazdir(ad, sehir)
+```
+```cikti
+Mert Trabzon
+```
+
+## Değişmezler
+
+Programda hiç değişmemesi gereken değerler için `degismez` kullan. Böyle bir değere yeniden atama yaparsan program derlenmez.
+
+```kbl
+degismez KDV_ORANI = 20
+fiyat = 150
+yazdir(fiyat + fiyat * KDV_ORANI / 100)
+```
+```cikti
+180.0
+```
+
+```kbl goster
+degismez KDV_ORANI = 20
+KDV_ORANI = 18     # hata: 'KDV_ORANI' değişmez — değeri değiştirilemez
+```
+
+> **İpucu:** Değişmezleri BÜYÜK_HARFLE yazmak yaygın bir alışkanlıktır; kodu okuyan biri onun değişmeyeceğini hemen anlar.
+
+## Alıştırma
+
+```alistirma
+`cuzdan` 200 TL ile başlıyor. Önce 45 TL'lik bir kitap al (`-=`), sonra 30 TL harçlık ekle (`+=`). Son durumu yazdır.
+%%%
+cuzdan = 200
+# buraya yaz
+yazdir(cuzdan)
+%%%
+cuzdan = 200
+cuzdan -= 45
+cuzdan += 30
+yazdir(cuzdan)
+%%%
+185
+```
+
+```alistirma
+`kenar` değişkeni bir karenin kenar uzunluğunu tutuyor. `alan` ve `cevre` adında iki değişken oluşturup karenin alanını ve çevresini hesapla, ikisini aynı satırda yazdır.
+%%%
+kenar = 7
+# buraya yaz
+%%%
+kenar = 7
+alan = kenar * kenar
+cevre = 4 * kenar
+yazdir(alan, cevre)
+%%%
+49 28
+```

dersler/05-veri-turleri.md

@@ -0,0 +1,111 @@
+---
+baslik: Veri türleri
+bolum: Temeller
+ozet: sayi, ondalik, metin, mantik ve tür belirtmek
+---
+
+Her değerin bir türü vardır. Tür, o değerle neler yapabileceğini belirler: sayılar toplanır, metinler birleştirilir, mantık değerleriyle karar verilir.
+
+## Dört temel tür
+
+| Tür | Ne tutar | Örnek |
+|---|---|---|
+| `sayi` | tam sayı | `42`, `-7`, `85_000_000` |
+| `ondalik` | küsuratlı sayı | `3.14`, `-0.5`, `1.0` |
+| `metin` | yazı | `"Kars"`, `""` |
+| `mantik` | doğru ya da yanlış | `dogru`, `yanlis` |
+
+```kbl
+il = "Kars"          # metin
+rakim = 1768         # sayi
+sicaklik = -4.5      # ondalik
+kar_yagiyor = dogru  # mantik
+yazdir(il, rakim, sicaklik, kar_yagiyor)
+```
+```cikti
+Kars 1768 -4.5 doğru
+```
+
+Mantık değerleri kodda `dogru`/`yanlis` diye yazılır ama ekranda Türkçe harflerle `doğru`/`yanlış` görünür.
+
+## sayi ve ondalik farklı türlerdir
+
+Ondalık sayılarda virgül değil **nokta** kullanılır. `3` bir `sayi`, `3.0` ise bir `ondalik`tır.
+
+```kbl
+a = 3
+b = 3.0
+yazdir(a)
+yazdir(b)
+```
+```cikti
+3
+3.0
+```
+
+Uzun sayılarda basamakları `_` ile ayırabilirsin; değer değişmez, okumak kolaylaşır.
+
+```kbl
+nufus = 85_000_000
+yazdir(nufus)
+```
+```cikti
+85000000
+```
+
+## Metinler
+
+Metin, tırnak içindeki yazıdır. Çift ya da tek tırnak kullanabilirsin. Hiç karakter içermeyen `""` boş metindir.
+
+```kbl
+selam = "Merhaba"
+isim = 'Zeynep'
+yazdir(selam + " " + isim)
+```
+```cikti
+Merhaba Zeynep
+```
+
+> **Dikkat:** `"42"` bir sayı değil, iki karakterlik bir metindir. `"42" + 1` derlenmez. Metinle sayı arasında geçişi *Tür dönüşümleri* dersinde göreceksin.
+
+## Türü açıkça yazmak
+
+Türü yazmak zorunlu değil ama istersen `ad: tur = değer` biçiminde yazabilirsin. Derleyici o zaman değerin o türde olduğunu denetler.
+
+```kbl
+fiyat: ondalik = 49.90
+stok: sayi = 12
+urun: metin = "Defter"
+yazdir(urun, stok, fiyat)
+```
+```cikti
+Defter 12 49.9
+```
+
+`49.90` ekranda `49.9` olarak görünür; sondaki sıfır sayının değerini değiştirmez. Biçimini kendin belirlemeyi *Biçimlendirme* dersinde öğreneceksin.
+
+## Türler karşılaştırılabilir mi?
+
+Farklı türden iki değeri karşılaştırmak anlamsızdır ve derleyici buna izin vermez:
+
+```kbl goster
+yazdir("5" == 5)   # hata: 'metin' ile 'sayi' karşılaştırılamaz
+```
+
+Bu bir kolaylıktır: yanlışlıkla metni sayıyla karşılaştırdığın bir hatayı program çalışmadan yakalarsın.
+
+## Alıştırma
+
+```alistirma
+Bir kitap için dört değişken oluştur: `ad` (metin, "Çalıkuşu"), `sayfa` (sayi, 544), `puan` (ondalik, 4.8), `okundu` (mantik, dogru). Dördünü tek bir `yazdir` ile sırayla yazdır.
+%%%
+# buraya yaz
+%%%
+ad = "Çalıkuşu"
+sayfa = 544
+puan = 4.8
+okundu = dogru
+yazdir(ad, sayfa, puan, okundu)
+%%%
+Çalıkuşu 544 4.8 doğru
+```

dersler/06-sayilar-aritmetik.md

@@ -0,0 +1,145 @@
+---
+baslik: Sayılar ve aritmetik
+bolum: Temeller
+ozet: Dört işlem, tam bölme, kalan, üs ve işlem önceliği
+---
+
+Bilgisayarın en iyi yaptığı iş hesaptır. Bu derste KabaLang'in aritmetik işleçlerini ve sık yapılan hesapları göreceksin.
+
+## Aritmetik işleçler
+
+| İşleç | Anlamı | Örnek | Sonuç |
+|---|---|---|---|
+| `+` | toplama | `17 + 5` | `22` |
+| `-` | çıkarma | `17 - 5` | `12` |
+| `*` | çarpma | `17 * 5` | `85` |
+| `/` | bölme | `17 / 5` | `3.4` |
+| `//` | tam bölme | `17 // 5` | `3` |
+| `%` | kalan | `17 % 5` | `2` |
+| `**` | üs alma | `2 ** 10` | `1024` |
+
+```kbl
+a = 17
+b = 5
+yazdir(a + b, a - b, a * b)
+yazdir(a / b, a // b, a % b)
+yazdir(2 ** 10)
+```
+```cikti
+22 12 85
+3.4 3 2
+1024
+```
+
+## / her zaman ondalık verir
+
+`/` bölmesinin sonucu, sayılar tam bölünse bile `ondalik`tır. Küsuratsız tam sayı istiyorsan `//` kullan.
+
+```kbl
+yazdir(10 / 2)
+yazdir(10 // 2)
+yazdir(7 // 2)
+```
+```cikti
+5.0
+5
+3
+```
+
+## Kalan işleci: %
+
+`%` bölümden kalanı verir. Bir sayının çift mi tek mi olduğunu, bir sayıya bölünüp bölünmediğini anlamak için kullanılır.
+
+```kbl
+yazdir(14 % 2)    # 0 ise çift
+yazdir(15 % 2)    # 1 ise tek
+yazdir(2026 % 4)  # 4'e tam bölünmüyor
+```
+```cikti
+0
+1
+2
+```
+
+## Gerçek bir hesap: saniyeyi saate çevirmek
+
+`//` ve `%` birlikte çok işe yarar.
+
+```kbl
+toplam_saniye = 7384
+saat = toplam_saniye // 3600
+dakika = (toplam_saniye % 3600) // 60
+saniye = toplam_saniye % 60
+yazdir(saat, "saat", dakika, "dakika", saniye, "saniye")
+```
+```cikti
+2 saat 3 dakika 4 saniye
+```
+
+## İşlem önceliği
+
+Matematikteki gibi: önce `**`, sonra `*` `/` `//` `%`, en son `+` `-`. Parantez önceliği değiştirir.
+
+```kbl
+yazdir(2 + 3 * 4)
+yazdir((2 + 3) * 4)
+yazdir(2 * 3 ** 2)
+```
+```cikti
+14
+20
+18
+```
+
+> **İpucu:** Emin olmadığın her yerde parantez kullan. `(a + b) / 2` hem doğru çalışır hem kolay okunur.
+
+## sayi ile ondalik birlikte
+
+Bir işlemde biri `sayi` öteki `ondalik` ise sonuç `ondalik` olur.
+
+```kbl
+adet = 3
+fiyat = 12.5
+yazdir(adet * fiyat)
+```
+```cikti
+37.5
+```
+
+> **Dikkat:** Ondalık sayılar bilgisayarda yaklaşık tutulur. `0.1 + 0.2` tam `0.3` değil `0.30000000000000004` çıkar. Bu her dilde böyledir; para gibi değerleri ekrana yazarken basamak sayısını sınırlarsın (*Biçimlendirme* dersi).
+
+```kbl
+yazdir(0.1 + 0.2)
+```
+```cikti
+0.30000000000000004
+```
+
+## Alıştırma
+
+```alistirma
+Bir sınıfta 29 öğrenci var ve 4 kişilik gruplar kurulacak. Kaç tam grup olacağını ve kaç öğrencinin açıkta kalacağını aynı satırda yazdır.
+%%%
+ogrenci = 29
+grup_buyuklugu = 4
+# buraya yaz
+%%%
+ogrenci = 29
+grup_buyuklugu = 4
+yazdir(ogrenci // grup_buyuklugu, ogrenci % grup_buyuklugu)
+%%%
+7 1
+```
+
+```alistirma
+Fahrenhayt'ı Celsius'a çevir: `C = (F - 32) * 5 / 9`. `f` değişkeni 212 iken sonucu yazdır.
+%%%
+f = 212
+# buraya yaz
+%%%
+f = 212
+c = (f - 32) * 5 / 9
+yazdir(c)
+%%%
+100.0
+```

dersler/07-tur-donusumleri.md

@@ -0,0 +1,130 @@
+---
+baslik: Tür dönüşümleri
+bolum: Temeller
+ozet: sayi(), ondalik() ve metin() ile türler arasında geçiş
+---
+
+Türler kendiliğinden birbirine dönüşmez. Kullanıcıdan ya da bir dosyadan gelen `"42"` bir metindir; onunla hesap yapmak için önce sayıya çevirmen gerekir. Dönüşümü her zaman açıkça yazarsın.
+
+## Üç dönüşüm fonksiyonu
+
+| Fonksiyon | Ne yapar | Örnek | Sonuç |
+|---|---|---|---|
+| `sayi(x)` | tam sayıya çevirir | `sayi("42")` | `42` |
+| `ondalik(x)` | ondalık sayıya çevirir | `ondalik("2.75")` | `2.75` |
+| `metin(x)` | metne çevirir | `metin(24)` | `"24"` |
+
+## Metinden sayıya
+
+```kbl
+yas_yazi = "17"
+yas = sayi(yas_yazi)
+yazdir(yas + 1)
+
+fiyat = ondalik("19.90")
+yazdir(fiyat * 2)
+```
+```cikti
+18
+39.8
+```
+
+Baştaki ve sondaki boşluklar sorun olmaz: `sayi(" 42 ")` da `42` verir.
+
+## Sayıdan metne
+
+Bir metni sayıyla `+` ile birleştiremezsin. Önce sayıyı `metin()` ile çevir.
+
+```kbl
+ogrenci = 24
+yazdir("Sınıfta " + metin(ogrenci) + " öğrenci var.")
+```
+```cikti
+Sınıfta 24 öğrenci var.
+```
+
+> **İpucu:** Metinle sayıyı yan yana yazmanın daha kolay bir yolu var: `f"Sınıfta {ogrenci} öğrenci var."`. Bunu *Biçimlendirme* dersinde göreceksin.
+
+## ondalik ile sayi arasında
+
+`sayi()` bir ondalığın küsuratını **atar**, yuvarlamaz. `ondalik()` tam sayıyı ondalığa çevirir.
+
+```kbl
+yazdir(sayi(3.99))
+yazdir(sayi(-3.99))
+yazdir(ondalik(7))
+yazdir(ondalik(7) / 2)
+```
+```cikti
+3
+-3
+7.0
+3.5
+```
+
+Yuvarlamak istiyorsan `matematik.yuvarla()` kullanırsın; onu *Modüller* dersinde göreceksin.
+
+## Mantık değerini metne çevirmek
+
+```kbl
+gecti = dogru
+yazdir("Sonuç: " + metin(gecti))
+```
+```cikti
+Sonuç: doğru
+```
+
+> **Dikkat:** `sayi()` yalnız tam sayı yazılmış bir metni doğru çevirir. `sayi("3.9")` ya da `sayi("on iki")` hata vermez ama **0** döndürür; bu da fark edilmesi zor bir yanlışa yol açar. Ondalık bir metni önce `ondalik()` ile çevir. Kullanıcıdan gelen sayıyı güvenle okumanın yolunu *Kullanıcıdan girdi* dersinde öğreneceksin.
+
+```kbl
+yazdir(sayi(ondalik("3.9")))
+```
+```cikti
+3
+```
+
+## Gerçek bir örnek: virgülle ayrılmış veriler
+
+Bir satırdaki verileri metin olarak alıp sayıya çevirerek hesap yapalım. `bol(";")` metni parçalara ayırır (ayrıntısı *Metin işlemleri* dersinde).
+
+```kbl
+satir = "Defter;3;24.50"
+parca = satir.bol(";")
+urun = parca[0]
+adet = sayi(parca[1])
+fiyat = ondalik(parca[2])
+yazdir(urun + ": " + metin(adet * fiyat) + " TL")
+```
+```cikti
+Defter: 73.5 TL
+```
+
+## Alıştırma
+
+```alistirma
+`a` ve `b` metin olarak verilmiş. İkisini sayıya çevirip toplamını yazdır.
+%%%
+a = "125"
+b = "75"
+# buraya yaz
+%%%
+a = "125"
+b = "75"
+yazdir(sayi(a) + sayi(b))
+%%%
+200
+```
+
+```alistirma
+`metin()` kullanarak `Toplam: 3 ürün, 45.5 TL` satırını yazdır. Sayıları değişkenlerden al, `+` ile birleştir.
+%%%
+adet = 3
+tutar = 45.5
+# buraya yaz
+%%%
+adet = 3
+tutar = 45.5
+yazdir("Toplam: " + metin(adet) + " ürün, " + metin(tutar) + " TL")
+%%%
+Toplam: 3 ürün, 45.5 TL
+```

dersler/08-metinler.md

@@ -0,0 +1,163 @@
+---
+baslik: Metinler
+bolum: Temeller
+ozet: Metin yazmak, birleştirmek, kaçış karakterleri ve harflere erişim
+---
+
+Ad, adres, mesaj, ürün açıklaması... Programların işlediği verilerin çoğu metindir. KabaLang metinleri Türkçe harflerle sorunsuz çalışır.
+
+## Metin oluşturmak
+
+Metin çift (`"..."`) ya da tek (`'...'`) tırnak arasına yazılır.
+
+```kbl
+sehir = "Çanakkale"
+ulke = 'Türkiye'
+yazdir(sehir)
+yazdir(ulke)
+```
+```cikti
+Çanakkale
+Türkiye
+```
+
+## Birleştirmek
+
+İki metni `+` ile uç uca eklersin. `+=` bir metnin sonuna ekleme yapar.
+
+```kbl
+ad = "Reşat Nuri"
+soyad = "Güntekin"
+tam_ad = ad + " " + soyad
+yazdir(tam_ad)
+
+mesaj = "Merhaba"
+mesaj += ", hoş geldin!"
+yazdir(mesaj)
+```
+```cikti
+Reşat Nuri Güntekin
+Merhaba, hoş geldin!
+```
+
+## Kaçış karakterleri
+
+Bazı karakterler ters eğik çizgiyle yazılır:
+
+| Yazım | Anlamı |
+|---|---|
+| `\n` | yeni satır |
+| `\t` | sekme |
+| `\"` | çift tırnak |
+| `\\` | ters eğik çizgi |
+
+```kbl
+yazdir("Birinci satır\nİkinci satır")
+yazdir("Öğretmen \"tahtaya bakın\" dedi.")
+yazdir("Dosya: C:\\belgeler")
+```
+```cikti
+Birinci satır
+İkinci satır
+Öğretmen "tahtaya bakın" dedi.
+Dosya: C:\belgeler
+```
+
+## Çok satırlı metin
+
+Üç tırnak (`"""`) arasına yazdığın metin, satır sonlarıyla birlikte olduğu gibi saklanır.
+
+```kbl
+siir = """Gün doğdu,
+kuşlar uyandı."""
+yazdir(siir)
+```
+```cikti
+Gün doğdu,
+kuşlar uyandı.
+```
+
+## Uzunluk
+
+`uzunluk()` metindeki karakter sayısını verir. ş, ğ, İ gibi harfler de tek karakter sayılır.
+
+```kbl
+il = "Şanlıurfa"
+yazdir(il.uzunluk())
+```
+```cikti
+9
+```
+
+## Harflere erişmek: indeks
+
+Metindeki her karakterin bir sıra numarası (indeks) vardır. Sayma **0'dan** başlar. Negatif indeks sondan sayar: `-1` son karakterdir.
+
+```kbl
+il = "Kayseri"
+yazdir(il[0])
+yazdir(il[1])
+yazdir(il[-1])
+```
+```cikti
+K
+a
+i
+```
+
+`[a..b]` ile a'dan b'ye kadar (b dahil) bir parça alırsın.
+
+```kbl
+il = "Kayseri"
+yazdir(il[0..2])
+yazdir(il[3..6])
+```
+```cikti
+Kay
+seri
+```
+
+> **Dikkat:** Metindeki bir harfi yerinde değiştiremezsin: `il[0] = "M"` derlenmez. Değişmiş bir metin istiyorsan yenisini oluşturursun, örneğin `"M" + il[1..6]`.
+
+## Harf harf gezmek
+
+`dongu harf icinde metin:` her turda bir karakter verir (döngüleri ileride ayrıntılı göreceksin).
+
+```kbl
+dongu harf icinde "Ağrı":
+    yazdir(harf)
+```
+```cikti
+A
+ğ
+r
+ı
+```
+
+## Alıştırma
+
+```alistirma
+`ad` ve `sehir` değişkenlerini `+` ile birleştirerek `Ayşe, Eskişehir'de yaşıyor.` satırını yazdır.
+%%%
+ad = "Ayşe"
+sehir = "Eskişehir"
+# buraya yaz
+%%%
+ad = "Ayşe"
+sehir = "Eskişehir"
+yazdir(ad + ", " + sehir + "'de yaşıyor.")
+%%%
+Ayşe, Eskişehir'de yaşıyor.
+```
+
+```alistirma
+`kelime` değişkeninin ilk harfini, son harfini ve uzunluğunu aynı satırda yazdır.
+%%%
+kelime = "Çiçekçi"
+# buraya yaz
+%%%
+kelime = "Çiçekçi"
+yazdir(kelime[0], kelime[-1], kelime.uzunluk())
+%%%
+Ç i 7
+```

dersler/09-metin-islemleri.md

@@ -0,0 +1,176 @@
+---
+baslik: Metin işlemleri
+bolum: Temeller
+ozet: buyut, kucult, kirp, bol, birlestir, degistir, bul ve diğer metin yöntemleri
+---
+
+Metinlerin kendi yöntemleri (metotları) vardır: `metin.yontem()` biçiminde çağrılır. Kullanıcının yazdığını temizlemek, bir cümleyi kelimelere ayırmak, bir sözcüğü değiştirmek bu yöntemlerle yapılır.
+
+## Türkçe büyük ve küçük harf
+
+`buyut()` bütün harfleri büyütür, `kucult()` küçültür. Türkçe kurallara uyar: `i` büyüyünce `İ`, `I` küçülünce `ı` olur.
+
+```kbl
+yazdir("istanbul".buyut())
+yazdir("ILIK IRMAK".kucult())
+yazdir("şişli öğüt".buyut())
+```
+```cikti
+İSTANBUL
+ılık ırmak
+ŞİŞLİ ÖĞÜT
+```
+
+Büyük/küçük harfe aldırmadan karşılaştırmak için iki tarafı da küçültürsün.
+
+```kbl
+girilen = "İZMİR"
+yazdir(girilen.kucult() == "izmir")
+```
+```cikti
+doğru
+```
+
+## Boşlukları temizlemek: kirp
+
+`kirp()` baştaki ve sondaki boşlukları atar. Kullanıcı girdisinde çok işe yarar.
+
+```kbl
+ham = "   Merhaba Dünya   "
+yazdir("[" + ham + "]")
+yazdir("[" + ham.kirp() + "]")
+```
+```cikti
+[   Merhaba Dünya   ]
+[Merhaba Dünya]
+```
+
+## Aramak
+
+| Yöntem | Sorusu | Sonuç |
+|---|---|---|
+| `icerir(x)` | x geçiyor mu? | `dogru`/`yanlis` |
+| `ile_baslar(x)` | x ile mi başlıyor? | `dogru`/`yanlis` |
+| `ile_biter(x)` | x ile mi bitiyor? | `dogru`/`yanlis` |
+| `bul(x)` | x nerede başlıyor? | indeks, yoksa `-1` |
+
+```kbl
+cumle = "Ankara Türkiye'nin başkentidir"
+yazdir(cumle.icerir("başkent"))
+yazdir(cumle.ile_baslar("Ankara"))
+yazdir(cumle.ile_biter("dir"))
+yazdir(cumle.bul("Türkiye"))
+yazdir(cumle.bul("İzmir"))
+```
+```cikti
+doğru
+doğru
+doğru
+7
+-1
+```
+
+## Değiştirmek: degistir
+
+`degistir(eski, yeni)` metindeki her `eski`yi `yeni` ile değiştirir. Asıl metin değişmez, yeni bir metin döner.
+
+```kbl
+duyuru = "Toplantı salı günü, salı saat 10'da."
+yeni = duyuru.degistir("salı", "çarşamba")
+yazdir(yeni)
+```
+```cikti
+Toplantı çarşamba günü, çarşamba saat 10'da.
+```
+
+## Parça almak
+
+`bastan(n)` ilk n karakteri, `sondan(n)` son n karakteri, `dilim(baslangic, adet)` belli bir yerden başlayan parçayı verir.
+
+```kbl
+kelime = "Karadeniz"
+yazdir(kelime.bastan(4))
+yazdir(kelime.sondan(5))
+yazdir(kelime.dilim(2, 3))
+```
+```cikti
+Kara
+deniz
+rad
+```
+
+## Bölmek ve birleştirmek
+
+`bol(ayrac)` metni parçalara ayırıp bir liste verir. `birlestir(ayrac)` ise bir metin listesini tek metne çevirir.
+
+```kbl
+satir = "Ayşe;Kaya;Eskişehir"
+alanlar = satir.bol(";")
+yazdir(alanlar)
+yazdir(alanlar[2])
+yazdir(alanlar.birlestir(" | "))
+```
+```cikti
+[Ayşe, Kaya, Eskişehir]
+Eskişehir
+Ayşe | Kaya | Eskişehir
+```
+
+## Diğer yararlı yöntemler
+
+```kbl
+yazdir("=".tekrarla(20))
+yazdir("".bos_mu())
+yazdir("abc".bos_mu())
+```
+```cikti
+====================
+doğru
+yanlış
+```
+
+> **Dikkat:** Yöntem adlarına dikkat: büyütme `buyut()`, küçültme `kucult()`, uzunluk `uzunluk()`'tür. `buyuk()`, `kucuk()` diye yöntem yoktur; derleyici "böyle bir metot bulunamadı" der.
+
+## Yöntemleri zincirlemek
+
+Her yöntem yeni bir metin döndürdüğü için arka arkaya yazabilirsin.
+
+```kbl
+girdi = "   ankara   "
+yazdir(girdi.kirp().buyut())
+```
+```cikti
+ANKARA
+```
+
+## Alıştırma
+
+```alistirma
+`eposta` değişkenindeki boşlukları temizle, harflerini küçült ve sonucu yazdır. Ardından temizlenmiş adresin `@` içerip içermediğini yazdır.
+%%%
+eposta = "  [email protected]  "
+# buraya yaz
+%%%
+eposta = "  [email protected]  "
+temiz = eposta.kirp().kucult()
+yazdir(temiz)
+yazdir(temiz.icerir("@"))
+%%%
+[email protected]
+doğru
+```
+
+```alistirma
+`liste` metnindeki ürünler virgülle ayrılmış. Metni böl, ürün sayısını yazdır, sonra ürünleri ` - ` ile birleştirip yazdır.
+%%%
+liste = "ekmek,süt,peynir,zeytin"
+# buraya yaz
+%%%
+liste = "ekmek,süt,peynir,zeytin"
+urunler = liste.bol(",")
+yazdir(urunler.uzunluk())
+yazdir(urunler.birlestir(" - "))
+%%%
+4
+ekmek - süt - peynir - zeytin
+```

dersler/10-bicimlendirme.md

@@ -0,0 +1,151 @@
+---
+baslik: Biçimlendirme
+bolum: Temeller
+ozet: f-string ile değerleri metne yerleştirmek, basamak ve hizalama
+---
+
+Metinle sayıları `+` ve `metin()` ile birleştirmek çabuk karışır. Biçimli metin (f-string) bunu çok kolaylaştırır: değişkenleri doğrudan metnin içine yazarsın.
+
+## f-string
+
+Metnin önüne `f` koy, değerleri süslü parantez `{}` içine yaz.
+
+```kbl
+ad = "Deniz"
+yas = 14
+yazdir(f"{ad} {yas} yaşında.")
+```
+```cikti
+Deniz 14 yaşında.
+```
+
+Süslü parantezin içine hesap da yazabilirsin.
+
+```kbl
+adet = 3
+fiyat = 12
+yazdir(f"{adet} kalem toplam {adet * fiyat} TL.")
+```
+```cikti
+3 kalem toplam 36 TL.
+```
+
+## Ondalık basamak sayısı
+
+`{deger:.2f}` virgülden sonra 2 basamak yazar ve yuvarlar.
+
+```kbl
+pi = 3.14159
+fiyat = 49.9
+yazdir(f"{pi:.2f}")
+yazdir(f"{fiyat:.2f} TL")
+yazdir(f"{0.1 + 0.2:.2f}")
+```
+```cikti
+3.14
+49.90 TL
+0.30
+```
+
+## Sıfırla doldurmak
+
+`{deger:02}` sayıyı en az 2 basamağa tamamlar; eksik basamaklar sıfır olur. Saat ve tarih yazarken işe yarar.
+
+```kbl
+saat = 9
+dakika = 5
+yazdir(f"{saat:02}:{dakika:02}")
+```
+```cikti
+09:05
+```
+
+## Binlik ayırıcı ve yüzde
+
+```kbl
+nufus = 85_372_377
+oran = 0.256
+yazdir(f"{nufus:,}")
+yazdir(f"{oran:.1%}")
+```
+```cikti
+85,372,377
+25.6%
+```
+
+## Hizalama
+
+`{deger:<10}` değeri 10 karakterlik alana sola, `{deger:>10}` sağa, `{deger:^10}` ortaya yaslar. Tablo yazmak için birebirdir.
+
+```kbl
+yazdir(f"[{'Rize':<8}]")
+yazdir(f"[{'Rize':>8}]")
+yazdir(f"[{'Rize':^8}]")
+```
+```cikti
+[Rize    ]
+[    Rize]
+[  Rize  ]
+```
+
+Hizalama ile basamak sayısını birlikte de verebilirsin: `{fiyat:>8.2f}`.
+
+```kbl
+yazdir(f"{'Ürün':<10}{'Fiyat':>8}")
+yazdir(f"{'Ekmek':<10}{12.5:>8.2f}")
+yazdir(f"{'Peynir':<10}{149.0:>8.2f}")
+```
+```cikti
+Ürün         Fiyat
+Ekmek        12.50
+Peynir      149.00
+```
+
+> **Dikkat:** f-string içinde metin yazarken iç tırnağı dıştakinden farklı seç: `f"{'Ürün':<10}"` doğrudur. Süslü parantezin kendisini yazmak için ikiler: `f"{{ }}"` ekrana `{ }` basar.
+
+## Özet tablo
+
+| Yazım | Anlamı | Örnek | Sonuç |
+|---|---|---|---|
+| `{x:.2f}` | 2 ondalık basamak | `{3.14159:.2f}` | `3.14` |
+| `{x:03}` | 3 basamağa sıfırla tamamla | `{7:03}` | `007` |
+| `{x:,}` | binlik ayırıcı | `{1234567:,}` | `1,234,567` |
+| `{x:.0%}` | yüzde | `{0.5:.0%}` | `50%` |
+| `{x:<6}` | sola yasla | `[{'ab':<6}]` | `[ab    ]` |
+| `{x:>6}` | sağa yasla | `[{'ab':>6}]` | `[    ab]` |
+| `{x:^6}` | ortala | `[{'ab':^6}]` | `[  ab  ]` |
+
+## Alıştırma
+
+```alistirma
+f-string kullanarak `Elif'in ortalaması: 84.67` satırını yazdır. Ortalamayı üç notun ortalaması olarak hesapla ve 2 basamakla yaz.
+%%%
+ad = "Elif"
+not1 = 78
+not2 = 91
+not3 = 85
+# buraya yaz
+%%%
+ad = "Elif"
+not1 = 78
+not2 = 91
+not3 = 85
+ortalama = (not1 + not2 + not3) / 3
+yazdir(f"{ad}'in ortalaması: {ortalama:.2f}")
+%%%
+Elif'in ortalaması: 84.67
+```
+
+```alistirma
+`toplam_dakika` değerini `SS:DD` biçiminde (iki basamaklı saat ve dakika) yazdır. 425 dakika `07:05` olmalı.
+%%%
+toplam_dakika = 425
+# buraya yaz
+%%%
+toplam_dakika = 425
+saat = toplam_dakika // 60
+dakika = toplam_dakika % 60
+yazdir(f"{saat:02}:{dakika:02}")
+%%%
+07:05
+```

dersler/11-mantik-karsilastirma.md

@@ -0,0 +1,159 @@
+---
+baslik: Mantık ve karşılaştırma
+bolum: Temeller
+ozet: dogru/yanlis, karşılaştırma işleçleri, ve/veya/degil ve işleçlerin özeti
+---
+
+Program karar verirken bir sorunun cevabına bakar: "puan 50'den büyük mü?", "kullanıcı adı doğru mu?". Bu soruların cevabı bir mantık değeridir: `dogru` ya da `yanlis`.
+
+## Karşılaştırma işleçleri
+
+| İşleç | Sorusu |
+|---|---|
+| `==` | eşit mi? |
+| `!=` | farklı mı? |
+| `<` | küçük mü? |
+| `<=` | küçük ya da eşit mi? |
+| `>` | büyük mü? |
+| `>=` | büyük ya da eşit mi? |
+
+```kbl
+yazdir(7 > 3)
+yazdir(7 == 3)
+yazdir(7 != 3)
+yazdir(5 <= 5)
+```
+```cikti
+doğru
+yanlış
+doğru
+doğru
+```
+
+> **Dikkat:** Eşitlik sorusu **iki** eşittir işaretiyle yazılır: `==`. Tek `=` atamadır, değeri değiştirir.
+
+## Metinleri karşılaştırmak
+
+Metinler harf harf karşılaştırılır; büyük/küçük harf fark eder.
+
+```kbl
+yazdir("elma" == "elma")
+yazdir("elma" == "Elma")
+yazdir("elma".kucult() == "Elma".kucult())
+```
+```cikti
+doğru
+yanlış
+doğru
+```
+
+## Sonucu değişkende tutmak
+
+Karşılaştırmanın sonucu bir değerdir; değişkene atayabilirsin.
+
+```kbl
+yas = 20
+ehliyet_alabilir = yas >= 18
+yazdir(ehliyet_alabilir)
+```
+```cikti
+doğru
+```
+
+## ve, veya, degil
+
+Birden çok koşulu birleştirmek için sözcük işleçleri kullanılır:
+
+| İşleç | Ne zaman doğru? |
+|---|---|
+| `a ve b` | ikisi de doğruysa |
+| `a veya b` | en az biri doğruysa |
+| `degil a` | a yanlışsa |
+
+```kbl
+yas = 16
+veli_izni = dogru
+yazdir(yas >= 18 ve veli_izni)
+yazdir(yas >= 18 veya veli_izni)
+yazdir(degil veli_izni)
+```
+```cikti
+yanlış
+doğru
+yanlış
+```
+
+> **Dikkat:** `&&`, `||`, `!` gibi simgeler KabaLang'de yoktur. Her zaman `ve`, `veya`, `degil` yaz.
+
+## Aralık sorusu
+
+Bir değerin iki sınır arasında olup olmadığını `ve` ile sorarsın.
+
+```kbl
+sicaklik = 22
+yazdir(sicaklik >= 18 ve sicaklik <= 26)
+```
+```cikti
+doğru
+```
+
+## Parantezle gruplamak
+
+`ve`, `veya`'dan önce hesaplanır. Uzun koşullarda parantez kullanmak hem doğru sonucu garanti eder hem okumayı kolaylaştırır. Artık yıl kuralı buna güzel bir örnek: yıl 4'e bölünür ve 100'e bölünmez **ya da** 400'e bölünür.
+
+```kbl
+yil = 2024
+artik = (yil % 4 == 0 ve yil % 100 != 0) veya yil % 400 == 0
+yazdir(artik)
+```
+```cikti
+doğru
+```
+
+## Tek satırda seçim
+
+`A eger kosul degilse B` ifadesi, koşul doğruysa A'yı, değilse B'yi verir.
+
+```kbl
+n = 7
+yazdir("çift" eger n % 2 == 0 degilse "tek")
+```
+```cikti
+tek
+```
+
+## İşleçlerin özeti
+
+| Tür | İşleçler |
+|---|---|
+| Aritmetik | `+` `-` `*` `/` `//` `%` `**` |
+| Atama | `=` `+=` `-=` `*=` |
+| Karşılaştırma | `==` `!=` `<` `<=` `>` `>=` |
+| Mantık | `ve` `veya` `degil` |
+
+## Alıştırma
+
+```alistirma
+Bir bilet indirimi şöyle: yaşı 12'den küçük **veya** 65'ten büyük olanlar indirim alır. `yas` için bu koşulun sonucunu yazdır.
+%%%
+yas = 70
+# buraya yaz
+%%%
+yas = 70
+yazdir(yas < 12 veya yas > 65)
+%%%
+doğru
+```
+
+```alistirma
+Bir şifre geçerli sayılmak için en az 8 karakter olmalı **ve** içinde boşluk bulunmamalı. `sifre` için `gecerli` değişkenini hesaplayıp yazdır.
+%%%
+sifre = "kirmizi kalem"
+# buraya yaz
+%%%
+sifre = "kirmizi kalem"
+gecerli = sifre.uzunluk() >= 8 ve degil sifre.icerir(" ")
+yazdir(gecerli)
+%%%
+yanlış
+```

dersler/12-kosullar.md

@@ -0,0 +1,164 @@
+---
+baslik: Koşullar
+bolum: Akış denetimi
+ozet: eger, degilse eger, degilse ile karar vermek
+---
+
+Program her zaman aynı şeyi yapmaz: hava sıcaksa bir şey, soğuksa başka bir şey söyler. `eger` ile kodun bir bölümünü yalnız belli bir durumda çalıştırırsın.
+
+## eger
+
+`eger kosul:` satırının altındaki girintili blok, koşul doğruysa çalışır.
+
+```kbl
+sicaklik = 31
+eger sicaklik > 30:
+    yazdir("Hava çok sıcak.")
+yazdir("İyi günler.")
+```
+```cikti
+Hava çok sıcak.
+İyi günler.
+```
+
+## degilse
+
+Koşul yanlışsa çalışacak bir blok istiyorsan `degilse:` ekle.
+
+```kbl
+bakiye = 80
+fiyat = 120
+eger bakiye >= fiyat:
+    yazdir("Ödeme yapıldı.")
+degilse:
+    yazdir("Bakiye yetersiz.")
+```
+```cikti
+Bakiye yetersiz.
+```
+
+## degilse eger: birden çok seçenek
+
+Seçenek ikiden fazlaysa `degilse eger` kullanırsın. Koşullar yukarıdan aşağıya denenir; **doğru çıkan ilk dal** çalışır, gerisi atlanır.
+
+```kbl
+puan = 77
+eger puan >= 85:
+    harf = "AA"
+degilse eger puan >= 70:
+    harf = "BA"
+degilse eger puan >= 60:
+    harf = "BB"
+degilse eger puan >= 50:
+    harf = "CC"
+degilse:
+    harf = "FF"
+yazdir(f"{puan} puan: {harf}")
+```
+```cikti
+77 puan: BA
+```
+
+> **Dikkat:** Sıralama önemlidir. Yukarıdaki örnekte önce `puan >= 50` sorulsaydı, 77 puan o dala girer ve `CC` alırdı. Eşikleri büyükten küçüğe sırala.
+
+## Birleşik koşullar
+
+Koşulda `ve`, `veya`, `degil` kullanabilirsin.
+
+```kbl
+yas = 16
+veli_izni = dogru
+eger yas >= 18 veya veli_izni:
+    yazdir("Geziye katılabilir.")
+degilse:
+    yazdir("Veli izni gerekli.")
+```
+```cikti
+Geziye katılabilir.
+```
+
+## İç içe koşul
+
+Bir `eger` bloğunun içinde başka bir `eger` olabilir.
+
+```kbl
+kullanici = "ayse"
+parola = "kirmizi-kalem"
+eger kullanici == "ayse":
+    eger parola == "kirmizi-kalem":
+        yazdir("Giriş başarılı.")
+    degilse:
+        yazdir("Parola yanlış.")
+degilse:
+    yazdir("Böyle bir kullanıcı yok.")
+```
+```cikti
+Giriş başarılı.
+```
+
+**Dene**'ye basıp parolayı değiştir; hangi dalın çalıştığını gör.
+
+## Gerçek bir örnek: kargo ücreti
+
+```kbl
+sepet = 420.0
+agirlik = 3.2
+eger sepet >= 500.0:
+    kargo = 0.0
+degilse eger agirlik <= 1.0:
+    kargo = 39.90
+degilse eger agirlik <= 5.0:
+    kargo = 59.90
+degilse:
+    kargo = 89.90
+yazdir(f"Kargo: {kargo:.2f} TL")
+eger kargo > 0.0:
+    yazdir(f"{500.0 - sepet:.2f} TL daha ekle, kargo bedava.")
+```
+```cikti
+Kargo: 59.90 TL
+80.00 TL daha ekle, kargo bedava.
+```
+
+> **İpucu:** Bir değişkeni `eger` dallarında oluşturuyorsan (yukarıdaki `kargo` gibi) her dalda aynı türde değer ver: hepsi `ondalik` ya da hepsi `sayi`.
+
+## Alıştırma
+
+```alistirma
+`sayi_degeri` pozitifse `pozitif`, negatifse `negatif`, sıfırsa `sıfır` yazdır.
+%%%
+sayi_degeri = -8
+# buraya yaz
+%%%
+sayi_degeri = -8
+eger sayi_degeri > 0:
+    yazdir("pozitif")
+degilse eger sayi_degeri < 0:
+    yazdir("negatif")
+degilse:
+    yazdir("sıfır")
+%%%
+negatif
+```
+
+```alistirma
+Vücut kitle indeksini (`kilo / (boy * boy)`) hesapla ve 1 basamakla yazdır. Sonra değer 18.5'ten küçükse `zayıf`, 25'ten küçükse `normal`, değilse `fazla kilolu` yazdır.
+%%%
+kilo = 68.0
+boy = 1.75
+# buraya yaz
+%%%
+kilo = 68.0
+boy = 1.75
+vki = kilo / (boy * boy)
+yazdir(f"{vki:.1f}")
+eger vki < 18.5:
+    yazdir("zayıf")
+degilse eger vki < 25.0:
+    yazdir("normal")
+degilse:
+    yazdir("fazla kilolu")
+%%%
+22.2
+normal
+```

dersler/13-iken-dongusu.md

@@ -0,0 +1,140 @@
+---
+baslik: iken döngüsü
+bolum: Akış denetimi
+ozet: Koşul doğru olduğu sürece tekrar etmek
+---
+
+Bir işi defalarca yapmak için aynı satırı tekrar tekrar yazmazsın; döngü kullanırsın. `iken` döngüsü, koşul doğru olduğu **sürece** bloğunu tekrarlar.
+
+## Temel kullanım
+
+```kbl
+sayac = 1
+iken sayac <= 5:
+    yazdir(sayac)
+    sayac += 1
+yazdir("Bitti")
+```
+```cikti
+1
+2
+3
+4
+5
+Bitti
+```
+
+Her turdan önce koşul sorulur. `sayac` 6 olunca koşul yanlış çıkar ve döngü biter.
+
+## Geri sayım
+
+```kbl
+kalan = 3
+iken kalan > 0:
+    yazdir(f"{kalan}...")
+    kalan -= 1
+yazdir("Kalkış!")
+```
+```cikti
+3...
+2...
+1...
+Kalkış!
+```
+
+## Toplam biriktirmek
+
+Döngüde bir değişkene her turda ekleme yaparak toplam bulursun.
+
+```kbl
+toplam = 0
+n = 1
+iken n <= 100:
+    toplam += n
+    n += 1
+yazdir(f"1'den 100'e kadar toplam: {toplam}")
+```
+```cikti
+1'den 100'e kadar toplam: 5050
+```
+
+## Kaç turda biteceğini bilmediğin işler
+
+`iken`, tekrar sayısını önceden bilmediğin durumlar için idealdir. Yıllık %40 faizle 10.000 TL kaç yılda iki katını geçer?
+
+```kbl
+para = 10_000.0
+yil = 0
+iken para < 20_000.0:
+    para = para * 1.40
+    yil += 1
+yazdir(f"{yil} yıl sonra: {para:,.2f} TL")
+```
+```cikti
+3 yıl sonra: 27,440.00 TL
+```
+
+Bir sayının basamaklarını tek tek ayırmak da böyle bir iştir.
+
+```kbl
+n = 4729
+basamak_toplami = 0
+iken n > 0:
+    basamak_toplami += n % 10
+    n = n // 10
+yazdir(basamak_toplami)
+```
+```cikti
+22
+```
+
+> **Dikkat:** Koşulu bir gün yanlış yapacak satırı unutursan döngü **sonsuza dek** döner. Aşağıdaki kodda `sayac` hiç artmıyor; program durmaz (IDE belli bir süre sonra onu keser).
+
+```kbl goster
+sayac = 1
+iken sayac <= 5:
+    yazdir(sayac)
+    # sayac += 1 unutuldu!
+```
+
+## Alıştırma
+
+```alistirma
+`iken` ile 2'nin kuvvetlerini yazdır: 1, 2, 4, 8, ... 1000'i geçmeyenleri, her biri ayrı satırda.
+%%%
+kuvvet = 1
+# buraya yaz
+%%%
+kuvvet = 1
+iken kuvvet <= 1000:
+    yazdir(kuvvet)
+    kuvvet *= 2
+%%%
+1
+2
+4
+8
+16
+32
+64
+128
+256
+512
+```
+
+```alistirma
+Bir kumbarada 0 TL var. Her hafta 35 TL atılıyor. Kumbara 500 TL'ye ulaşana ya da geçene kadar kaç hafta gerektiğini ve son tutarı `X hafta, Y TL` biçiminde yazdır.
+%%%
+kumbara = 0
+hafta = 0
+# buraya yaz
+%%%
+kumbara = 0
+hafta = 0
+iken kumbara < 500:
+    kumbara += 35
+    hafta += 1
+yazdir(f"{hafta} hafta, {kumbara} TL")
+%%%
+15 hafta, 525 TL
+```

dersler/14-dongu-icinde.md

@@ -0,0 +1,150 @@
+---
+baslik: dongu ... icinde ve aralıklar
+bolum: Akış denetimi
+ozet: Bir listenin, metnin ya da sayı aralığının her öğesi için tekrar etmek
+---
+
+Elinde bir şehir listesi var ve her birini yazdırmak istiyorsun. `dongu x icinde ...` döngüsü bir topluluğun her öğesi için bloğunu bir kez çalıştırır; sayaç tutmana gerek kalmaz.
+
+## Liste üzerinde dönmek
+
+Her turda `sehir` değişkeni sıradaki öğeyi alır.
+
+```kbl
+sehirler = ["Ankara", "İzmir", "Trabzon", "Van"]
+dongu sehir icinde sehirler:
+    yazdir(f"• {sehir}")
+```
+```cikti
+• Ankara
+• İzmir
+• Trabzon
+• Van
+```
+
+Döngü değişkenine istediğin adı verebilirsin. Anlamlı bir ad seç: `dongu ogrenci icinde ogrenciler`.
+
+## Sayı aralığı: a..b
+
+`1..5` aralığı 1, 2, 3, 4, 5 demektir. **Üst sınır dahildir.**
+
+```kbl
+dongu i icinde 1..5:
+    yazdir(f"{i} x 3 = {i * 3}")
+```
+```cikti
+1 x 3 = 3
+2 x 3 = 6
+3 x 3 = 9
+4 x 3 = 12
+5 x 3 = 15
+```
+
+Sınırlar değişken ya da hesap olabilir.
+
+```kbl
+n = 4
+toplam = 0
+dongu i icinde 1..n:
+    toplam += i * i
+yazdir(f"1'den {n}'e kadar karelerin toplamı: {toplam}")
+```
+```cikti
+1'den 4'e kadar karelerin toplamı: 30
+```
+
+## İndeksle dönmek
+
+Sıra numarasına da ihtiyacın varsa `0..liste.uzunluk() - 1` aralığında dönersin.
+
+```kbl
+kazananlar = ["Elif", "Mert", "Zeynep"]
+dongu i icinde 0..kazananlar.uzunluk() - 1:
+    yazdir(f"{i + 1}. {kazananlar[i]}")
+```
+```cikti
+1. Elif
+2. Mert
+3. Zeynep
+```
+
+## Metin üzerinde dönmek
+
+Bir metin üzerinde dönünce her turda bir karakter gelir.
+
+```kbl
+kelime = "Çalışkan öğrenciler"
+unlu = 0
+dongu harf icinde kelime.kucult():
+    eger "aeıioöuü".icerir(harf):
+        unlu += 1
+yazdir(f"{unlu} ünlü harf var.")
+```
+```cikti
+7 ünlü harf var.
+```
+
+## İç içe döngü
+
+Dıştaki döngünün her turunda içteki döngü baştan sona çalışır. Çarpım tablosu buna klasik bir örnektir.
+
+```kbl
+dongu satir icinde 1..4:
+    cizgi = ""
+    dongu sutun icinde 1..4:
+        cizgi += f"{satir * sutun:4}"
+    yazdir(cizgi)
+```
+```cikti
+   1   2   3   4
+   2   4   6   8
+   3   6   9  12
+   4   8  12  16
+```
+
+> **Dikkat:** Aralık yalnız ileri sayar. `5..1` boş bir aralıktır, döngü hiç çalışmaz. Geri saymak için `iken` kullan.
+
+```kbl
+dongu i icinde 5..1:
+    yazdir(i)
+yazdir("Döngü hiç çalışmadı.")
+```
+```cikti
+Döngü hiç çalışmadı.
+```
+
+> **İpucu:** Döngü değişkenini değiştirmek listeyi değiştirmez. `dongu x icinde l: x = x * 2` yazınca `l` aynı kalır. Listeyi güncellemenin yolunu *Liste işlemleri* dersinde göreceksin.
+
+## Alıştırma
+
+```alistirma
+`notlar` listesindeki notların toplamını ve ortalamasını bul. Ortalamayı 1 basamakla `Toplam: 404, ortalama: 80.8` biçiminde yazdır.
+%%%
+notlar = [72, 95, 88, 61, 88]
+toplam = 0
+# buraya yaz
+%%%
+notlar = [72, 95, 88, 61, 88]
+toplam = 0
+dongu n icinde notlar:
+    toplam += n
+ortalama = toplam / notlar.uzunluk()
+yazdir(f"Toplam: {toplam}, ortalama: {ortalama:.1f}")
+%%%
+Toplam: 404, ortalama: 80.8
+```
+
+```alistirma
+1'den 5'e kadar her `n` için `n` tane yıldızdan oluşan bir satır yazdır (bir merdiven). `"*".tekrarla(n)` işini görür.
+%%%
+# buraya yaz
+%%%
+dongu n icinde 1..5:
+    yazdir("*".tekrarla(n))
+%%%
+*
+**
+***
+****
+*****
+```

dersler/15-kir-devam.md

@@ -0,0 +1,146 @@
+---
+baslik: kir ve devam
+bolum: Akış denetimi
+ozet: Döngüden erken çıkmak ve bir turu atlamak
+---
+
+Bazen döngünün sonuna kadar gitmek gerekmez: aradığını bulmuşsundur ya da bu turdaki öğe seni ilgilendirmiyordur. `kir` döngüden tümden çıkar, `devam` yalnız bu turu atlar.
+
+## kir: döngüden çık
+
+Listede ilk başarısız notu arayalım. Bulunca aramaya devam etmenin anlamı yok.
+
+```kbl
+notlar = [62, 81, 48, 77, 35]
+dongu n icinde notlar:
+    eger n < 50:
+        yazdir(f"İlk başarısız not: {n}")
+        kir
+    yazdir(f"{n} geçti")
+```
+```cikti
+62 geçti
+81 geçti
+İlk başarısız not: 48
+```
+
+`kir` çalışınca döngü hemen biter; 77 ve 35'e hiç bakılmaz.
+
+## devam: bu turu atla
+
+`devam`'a gelince turun geri kalanı atlanır, döngü bir sonraki öğeyle sürer.
+
+```kbl
+dongu i icinde 1..10:
+    eger i % 3 == 0:
+        devam
+    konsol.yaz(f"{i} ")
+yazdir()
+```
+```cikti
+1 2 4 5 7 8 10
+```
+
+Burada `konsol.yaz` kullandık: `yazdir` gibidir ama satırı bitirmez, böylece sayılar yan yana dizilir. En sondaki boş `yazdir()` satırı kapatır.
+
+## iken dogru ile kir
+
+Kaç tur süreceği belli olmayan bir döngüyü `iken dogru:` ile başlatıp koşul sağlanınca `kir` ile bitirebilirsin.
+
+```kbl
+n = 27
+adim = 0
+iken dogru:
+    eger n == 1:
+        kir
+    eger n % 2 == 0:
+        n = n // 2
+    degilse:
+        n = 3 * n + 1
+    adim += 1
+yazdir(f"27, {adim} adımda 1'e ulaştı.")
+```
+```cikti
+27, 111 adımda 1'e ulaştı.
+```
+
+> **Dikkat:** `iken dogru:` yazdıysan döngünün içinde mutlaka bir `kir` olmalı ve ona bir gün ulaşılmalı. Yoksa döngü sonsuza dek döner.
+
+## İç içe döngüde kir
+
+`kir` yalnız **içinde bulunduğu** döngüden çıkar; dıştaki döngü devam eder.
+
+```kbl
+dongu satir icinde 1..3:
+    dongu sutun icinde 1..3:
+        eger sutun > satir:
+            kir
+        konsol.yaz(f"{satir}{sutun} ")
+    yazdir()
+```
+```cikti
+11
+21 22
+31 32 33
+```
+
+## Hepsi bir arada: asal sayılar
+
+Bir sayı, 1 ve kendisinden başka böleni yoksa asaldır. Her aday için bölen arıyoruz; bulunca `kir` ile içteki döngüden çıkıyoruz.
+
+```kbl
+dongu aday icinde 2..30:
+    asal = dogru
+    bolen = 2
+    iken bolen * bolen <= aday:
+        eger aday % bolen == 0:
+            asal = yanlis
+            kir
+        bolen += 1
+    eger asal:
+        konsol.yaz(f"{aday} ")
+yazdir()
+```
+```cikti
+2 3 5 7 11 13 17 19 23 29
+```
+
+## Alıştırma
+
+```alistirma
+`urunler` listesinde ilk `"süt"`ü bul: bulunduğu sırayı (1'den sayarak) `süt 3. sırada` biçiminde yazdır ve döngüden çık.
+%%%
+urunler = ["ekmek", "peynir", "süt", "yumurta", "süt"]
+sira = 0
+dongu u icinde urunler:
+    sira += 1
+    # buraya yaz
+%%%
+urunler = ["ekmek", "peynir", "süt", "yumurta", "süt"]
+sira = 0
+dongu u icinde urunler:
+    sira += 1
+    eger u == "süt":
+        yazdir(f"süt {sira}. sırada")
+        kir
+%%%
+süt 3. sırada
+```
+
+```alistirma
+1'den 20'ye kadar sayıları gez. Çift sayıları `devam` ile atla, tek sayıların toplamını bulup yazdır.
+%%%
+toplam = 0
+dongu i icinde 1..20:
+    # buraya yaz
+yazdir(toplam)
+%%%
+toplam = 0
+dongu i icinde 1..20:
+    eger i % 2 == 0:
+        devam
+    toplam += i
+yazdir(toplam)
+%%%
+100
+```

dersler/16-listeler.md

@@ -0,0 +1,159 @@
+---
+baslik: Listeler
+bolum: Veri yapıları
+ozet: Değerleri sırayla tutmak, indeksle okumak ve değiştirmek
+---
+
+Bir sınıfın 30 notunu 30 ayrı değişkende tutamazsın. Liste, birçok değeri sırayla tek bir adın altında tutar.
+
+## Liste oluşturmak
+
+Köşeli parantez içine öğeleri virgülle ayırarak yazarsın.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+notlar = [72, 95, 48, 88]
+yazdir(meyveler)
+yazdir(notlar)
+```
+```cikti
+[elma, armut, kiraz]
+[72, 95, 48, 88]
+```
+
+Bir listedeki öğelerin hepsi **aynı türde** olmalıdır: hepsi sayı, hepsi metin gibi.
+
+## Uzunluk
+
+`uzunluk()` listedeki öğe sayısını verir.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+yazdir(meyveler.uzunluk())
+```
+```cikti
+3
+```
+
+## Öğelere erişmek
+
+Her öğenin bir sıra numarası (indeksi) vardır. Sayma **0'dan** başlar. Negatif indeks sondan sayar.
+
+```kbl
+gunler = ["Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma"]
+yazdir(gunler[0])
+yazdir(gunler[2])
+yazdir(gunler[-1])
+yazdir(gunler[-2])
+```
+```cikti
+Pazartesi
+Çarşamba
+Cuma
+Perşembe
+```
+
+> **Dikkat:** Listede olmayan bir indeksi okumak programı durdurur. 5 öğeli bir listede geçerli indeksler 0'dan 4'e kadardır; `gunler[5]` çalışma anında "liste sınır dışı" hatası verir.
+
+## Öğe değiştirmek
+
+İndeksle bir öğeye yeni değer atayabilirsin.
+
+```kbl
+sepet = ["ekmek", "süt", "çay"]
+sepet[1] = "ayran"
+yazdir(sepet)
+```
+```cikti
+[ekmek, ayran, çay]
+```
+
+## Parça almak
+
+`liste[a..b]` a'dan b'ye kadar olan öğeleri (b dahil) yeni bir liste olarak verir. `dilim(baslangic, adet)` ise bir yerden başlayıp belli sayıda öğe alır.
+
+```kbl
+sayilar = [10, 20, 30, 40, 50, 60]
+yazdir(sayilar[1..3])
+yazdir(sayilar.dilim(3, 2))
+```
+```cikti
+[20, 30, 40]
+[40, 50]
+```
+
+## Boş listeyle başlamak ve ekleme
+
+`[]` boş bir listedir. `ekle()` sona bir öğe ekler.
+
+```kbl
+alisveris = []
+alisveris.ekle("domates")
+alisveris.ekle("biber")
+alisveris.ekle("patlıcan")
+yazdir(alisveris)
+yazdir(alisveris.uzunluk())
+```
+```cikti
+[domates, biber, patlıcan]
+3
+```
+
+> **İpucu:** Boş listenin türü, ona ilk eklediğin değerden anlaşılır. Türü baştan belirtmek istersen `notlar: liste<sayi> = []` yazabilirsin.
+
+## Liste ve döngü
+
+Listeler en çok döngüyle birlikte kullanılır.
+
+```kbl
+fiyatlar = [12.5, 34.9, 8.75]
+toplam = 0.0
+dongu f icinde fiyatlar:
+    toplam += f
+yazdir(f"Toplam: {toplam:.2f} TL")
+```
+```cikti
+Toplam: 56.15 TL
+```
+
+## Liste içinde liste
+
+Listenin öğeleri de liste olabilir; tablo gibi düşünebilirsin. `tablo[satir][sutun]` diye okunur.
+
+```kbl
+tablo = [[3, 8, 1], [9, 4, 7]]
+yazdir(tablo[0])
+yazdir(tablo[1][0])
+```
+```cikti
+[3, 8, 1]
+9
+```
+
+## Alıştırma
+
+```alistirma
+`sehirler` listesinin ilk ve son öğesini ve öğe sayısını aynı satırda yazdır.
+%%%
+sehirler = ["Edirne", "Bursa", "Konya", "Kars"]
+# buraya yaz
+%%%
+sehirler = ["Edirne", "Bursa", "Konya", "Kars"]
+yazdir(sehirler[0], sehirler[-1], sehirler.uzunluk())
+%%%
+Edirne Kars 4
+```
+
+```alistirma
+Boş bir `kareler` listesi oluştur. 1'den 6'ya kadar her sayının karesini listeye ekle ve listeyi yazdır.
+%%%
+kareler = []
+# buraya yaz
+%%%
+kareler = []
+dongu i icinde 1..6:
+    kareler.ekle(i * i)
+yazdir(kareler)
+%%%
+[1, 4, 9, 16, 25, 36]
+```

dersler/17-liste-islemleri.md

@@ -0,0 +1,186 @@
+---
+baslik: Liste işlemleri
+bolum: Veri yapıları
+ozet: Aramak, silmek, sıralamak, birleştirmek ve koleksiyon modülü
+---
+
+Listeyi oluşturmayı öğrendin. Şimdi listeyle yapılan günlük işlere bakalım: bir öğe var mı, nerede, nasıl silinir, nasıl sıralanır.
+
+## Aramak: icerir ve bul
+
+`icerir(x)` öğe listede var mı diye sorar. `bul(x)` öğenin indeksini verir; yoksa `-1` döner.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+yazdir(meyveler.icerir("kiraz"))
+yazdir(meyveler.bul("kiraz"))
+yazdir(meyveler.bul("karpuz"))
+```
+```cikti
+doğru
+2
+-1
+```
+
+## Silmek: sil
+
+`sil(i)` **i'nci sıradaki** öğeyi siler; değere göre değil, konuma göre çalışır. Bir değeri silmek için önce `bul()` ile yerini bulursun.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz", "muz"]
+meyveler.sil(0)
+yazdir(meyveler)
+konum = meyveler.bul("kiraz")
+eger konum != -1:
+    meyveler.sil(konum)
+yazdir(meyveler)
+```
+```cikti
+[armut, kiraz, muz]
+[armut, muz]
+```
+
+`temizle()` bütün öğeleri siler, `bos_mu()` listenin boş olup olmadığını söyler.
+
+```kbl
+sepet = ["ekmek", "süt"]
+sepet.temizle()
+yazdir(sepet.bos_mu())
+```
+```cikti
+doğru
+```
+
+## Sıralamak: sirala
+
+`sirala()` listeyi yerinde, küçükten büyüğe dizer. Metinler Türk alfabesine göre sıralanır: Ç, C'den sonra; İ, I'dan sonra gelir.
+
+```kbl
+notlar = [72, 95, 48, 88]
+notlar.sirala()
+yazdir(notlar)
+
+isimler = ["Zeynep", "Ömer", "Can", "Çağla", "İlker", "Işıl", "Ahmet"]
+isimler.sirala()
+yazdir(isimler)
+```
+```cikti
+[48, 72, 88, 95]
+[Ahmet, Can, Çağla, Işıl, İlker, Ömer, Zeynep]
+```
+
+## Metne çevirmek: birlestir
+
+Bir metin listesini `birlestir(ayrac)` ile tek bir metne çevirirsin.
+
+```kbl
+renkler = ["kırmızı", "beyaz"]
+yazdir(renkler.birlestir(" ve "))
+```
+```cikti
+kırmızı ve beyaz
+```
+
+## Koşula uyanları toplamak
+
+Boş bir listeyle başlayıp koşula uyan öğeleri eklemek çok sık yapılan bir iştir.
+
+```kbl
+notlar = [72, 95, 48, 88, 35, 61]
+gecenler = []
+dongu n icinde notlar:
+    eger n >= 50:
+        gecenler.ekle(n)
+yazdir(gecenler)
+```
+```cikti
+[72, 95, 88, 61]
+```
+
+## Öğeleri indeksle güncellemek
+
+Listedeki her öğeyi değiştirmek için indeksle dönersin.
+
+```kbl
+fiyatlar = [100, 250, 40]
+dongu i icinde 0..fiyatlar.uzunluk() - 1:
+    fiyatlar[i] = fiyatlar[i] * 2
+yazdir(fiyatlar)
+```
+```cikti
+[200, 500, 80]
+```
+
+## koleksiyon modülü
+
+Toplam, en büyük, en küçük gibi işler için `kullan kaba.koleksiyon` yazıp hazır fonksiyonları kullanabilirsin. Bu fonksiyonlar asıl listeyi değiştirmez, sonuç döndürür.
+
+```kbl
+kullan kaba.koleksiyon
+notlar = [72, 95, 48, 88, 72]
+yazdir(koleksiyon.topla(notlar))
+yazdir(koleksiyon.en_buyuk(notlar))
+yazdir(koleksiyon.en_kucuk(notlar))
+yazdir(koleksiyon.say(notlar, 72))
+yazdir(koleksiyon.sirali(notlar))
+yazdir(koleksiyon.ters(notlar))
+yazdir(notlar)
+```
+```cikti
+375
+95
+48
+2
+[48, 72, 72, 88, 95]
+[72, 88, 48, 95, 72]
+[72, 95, 48, 88, 72]
+```
+
+| Fonksiyon | Ne verir |
+|---|---|
+| `koleksiyon.topla(l)` | öğelerin toplamı |
+| `koleksiyon.en_buyuk(l)` / `en_kucuk(l)` | en büyük / en küçük öğe |
+| `koleksiyon.say(l, x)` | x kaç kez geçiyor |
+| `koleksiyon.sirali(l)` | sıralı bir kopya |
+| `koleksiyon.ters(l)` | ters çevrilmiş bir kopya |
+| `koleksiyon.benzersiz(l)` | tekrarları atılmış bir kopya |
+
+> **Dikkat:** Listenin kendisinde `toplam()`, `en_buyuk()` ya da `ters_cevir()` diye yöntem yoktur. Bunlar için ya döngü yazarsın ya da `koleksiyon` modülünü kullanırsın.
+
+## Alıştırma
+
+```alistirma
+`misafirler` listesinden `"Kemal"`i sil (önce `bul` ile yerini bul), sonra listeyi alfabetik sırala ve virgülle birleştirip yazdır.
+%%%
+misafirler = ["Selin", "Kemal", "Burak", "Ayla"]
+# buraya yaz
+%%%
+misafirler = ["Selin", "Kemal", "Burak", "Ayla"]
+konum = misafirler.bul("Kemal")
+misafirler.sil(konum)
+misafirler.sirala()
+yazdir(misafirler.birlestir(", "))
+%%%
+Ayla, Burak, Selin
+```
+
+```alistirma
+`sicakliklar` listesindeki en yüksek ve en düşük değeri **döngüyle** (modül kullanmadan) bul ve `En yüksek 31, en düşük 18` biçiminde yazdır.
+%%%
+sicakliklar = [24, 31, 18, 27, 22]
+en_yuksek = sicakliklar[0]
+en_dusuk = sicakliklar[0]
+# buraya yaz
+%%%
+sicakliklar = [24, 31, 18, 27, 22]
+en_yuksek = sicakliklar[0]
+en_dusuk = sicakliklar[0]
+dongu s icinde sicakliklar:
+    eger s > en_yuksek:
+        en_yuksek = s
+    eger s < en_dusuk:
+        en_dusuk = s
+yazdir(f"En yüksek {en_yuksek}, en düşük {en_dusuk}")
+%%%
+En yüksek 31, en düşük 18
+```

dersler/18-sozlukler.md

@@ -0,0 +1,176 @@
+---
+baslik: Sözlükler
+bolum: Veri yapıları
+ozet: Anahtar-değer çiftleri, ekleme, sorgulama, gezme ve sayım
+---
+
+Listede bir öğeye sıra numarasıyla ulaşırsın. Ama "Ankara'nın plakası kaç?" sorusunda sıra numarası işe yaramaz. Sözlük, her değeri bir **anahtarla** eşleştirir: `plaka["Ankara"]` gibi.
+
+## Sözlük oluşturmak
+
+Süslü parantez içine `anahtar: değer` çiftlerini virgülle ayırarak yazarsın.
+
+```kbl
+plaka = {"İstanbul": 34, "Ankara": 6, "İzmir": 35}
+yazdir(plaka["Ankara"])
+yazdir(plaka.uzunluk())
+```
+```cikti
+6
+3
+```
+
+## Ekleme ve güncelleme
+
+Olmayan bir anahtara değer atamak yeni çift ekler; var olan bir anahtara atamak değeri değiştirir.
+
+```kbl
+stok = {"elma": 40, "armut": 25}
+stok["kiraz"] = 12
+stok["elma"] = stok["elma"] - 5
+yazdir(stok["elma"])
+yazdir(stok["kiraz"])
+```
+```cikti
+35
+12
+```
+
+## Anahtar var mı?
+
+Sözlükte olmayan bir anahtarı okumak programı hatayla durdurur. Emin değilsen önce `var_mi()` ile sor.
+
+```kbl
+plaka = {"İstanbul": 34, "Ankara": 6}
+dongu sehir icinde ["Ankara", "Konya"]:
+    eger plaka.var_mi(sehir):
+        yazdir(f"{sehir}: {plaka[sehir]}")
+    degilse:
+        yazdir(f"{sehir}: kayıtlı değil")
+```
+```cikti
+Ankara: 6
+Konya: kayıtlı değil
+```
+
+## Silmek
+
+Sözlükte `sil()` **anahtara** göre siler (listede konuma göre silerdi).
+
+```kbl
+stok = {"elma": 40, "armut": 25, "kiraz": 12}
+stok.sil("armut")
+yazdir(stok.uzunluk())
+yazdir(stok.var_mi("armut"))
+```
+```cikti
+2
+yanlış
+```
+
+## Sözlükte gezmek
+
+`anahtarlar()` bütün anahtarları bir liste olarak verir. Her anahtar için değeri `sozluk[anahtar]` ile okursun.
+
+```kbl
+fiyat = {"ekmek": 12.5, "süt": 34.9, "peynir": 149.0}
+anahtarlar = fiyat.anahtarlar()
+anahtarlar.sirala()
+dongu urun icinde anahtarlar:
+    yazdir(f"{urun:<8}{fiyat[urun]:>8.2f} TL")
+```
+```cikti
+ekmek      12.50 TL
+peynir    149.00 TL
+süt        34.90 TL
+```
+
+> **Dikkat:** `anahtarlar()` listesi ekleme sırasında gelmez. Belli bir sırada gezmek istiyorsan yukarıdaki gibi önce `sirala()` ile sırala.
+
+## Sayım: en sık kullanılan sözlük işi
+
+Bir metinde hangi kelimenin kaç kez geçtiğini sayalım. Her kelime için: daha önce gördüysek sayısını artırırız, görmediysek 1 ile başlatırız.
+
+```kbl
+cumle = "bir elma bir armut iki elma bir kiraz"
+sayim = {}
+dongu kelime icinde cumle.bol(" "):
+    eger sayim.var_mi(kelime):
+        sayim[kelime] = sayim[kelime] + 1
+    degilse:
+        sayim[kelime] = 1
+kelimeler = sayim.anahtarlar()
+kelimeler.sirala()
+dongu k icinde kelimeler:
+    yazdir(f"{k}: {sayim[k]}")
+```
+```cikti
+armut: 1
+bir: 3
+elma: 2
+iki: 1
+kiraz: 1
+```
+
+## Değerleri toplamak
+
+Bir sözlükteki sayıların toplamını anahtarlar üzerinden dönerek bulursun.
+
+```kbl
+notlar = {"Ayşe": 88, "Mehmet": 64, "Elif": 92}
+toplam = 0
+dongu ad icinde notlar.anahtarlar():
+    toplam += notlar[ad]
+yazdir(f"Ortalama: {toplam / notlar.uzunluk():.1f}")
+```
+```cikti
+Ortalama: 81.3
+```
+
+> **İpucu:** Bir sözlüğün bütün değerleri aynı türde olsun: hepsi sayı ya da hepsi metin. Öğrencinin adını, notunu ve şehrini birlikte tutmak istiyorsan *Yapılar* dersindeki `yapi` daha uygun bir araçtır.
+
+## Alıştırma
+
+```alistirma
+`telefon` sözlüğüne `"Can": "0532 111 22 33"` kaydını ekle. Sonra `"Can"` ve `"Deniz"` için ya numarayı ya da `Deniz: bulunamadı` yazdır.
+%%%
+telefon = {"Ayşe": "0555 123 45 67"}
+# buraya yaz
+%%%
+telefon = {"Ayşe": "0555 123 45 67"}
+telefon["Can"] = "0532 111 22 33"
+dongu ad icinde ["Can", "Deniz"]:
+    eger telefon.var_mi(ad):
+        yazdir(f"{ad}: {telefon[ad]}")
+    degilse:
+        yazdir(f"{ad}: bulunamadı")
+%%%
+Can: 0532 111 22 33
+Deniz: bulunamadı
+```
+
+```alistirma
+`metin_` içindeki her harfin kaç kez geçtiğini say (boşlukları atla). Harfleri sıralayıp `a 3` biçiminde, her biri ayrı satırda yazdır.
+%%%
+metin_ = "kar kara"
+sayim = {}
+# buraya yaz
+%%%
+metin_ = "kar kara"
+sayim = {}
+dongu h icinde metin_:
+    eger h == " ":
+        devam
+    eger sayim.var_mi(h):
+        sayim[h] = sayim[h] + 1
+    degilse:
+        sayim[h] = 1
+harfler = sayim.anahtarlar()
+harfler.sirala()
+dongu h icinde harfler:
+    yazdir(f"{h} {sayim[h]}")
+%%%
+a 3
+k 2
+r 2
+```

dersler/19-fonksiyonlar.md

@@ -0,0 +1,168 @@
+---
+baslik: Fonksiyon tanımlama
+bolum: Fonksiyonlar
+ozet: Bir işi adlandırıp istediğin kadar çağırmak
+---
+
+Aynı kodu programın üç yerinde yazıyorsan, bir yerde hata yaptığında üç yerde düzeltmen gerekir. Fonksiyon, bir işi yapan ve bir adı olan kod bloğudur: bir kez yazarsın, istediğin kadar çağırırsın.
+
+## İlk fonksiyonun
+
+Tanım `fonksiyon ad():` ile başlar; gövdesi girintilidir. Fonksiyon tanımlandığında çalışmaz, **çağrıldığında** çalışır.
+
+```kbl
+fonksiyon ayrac():
+    yazdir("─".tekrarla(20))
+
+ayrac()
+yazdir("Günün menüsü")
+ayrac()
+```
+```cikti
+────────────────────
+Günün menüsü
+────────────────────
+```
+
+## Parametre almak
+
+Parantez içine yazdığın ad bir **parametredir**. Çağırırken verdiğin değer onun yerine geçer.
+
+```kbl
+fonksiyon selamla(ad):
+    yazdir(f"Merhaba {ad}, hoş geldin.")
+
+selamla("Zeynep")
+selamla("Mehmet")
+```
+```cikti
+Merhaba Zeynep, hoş geldin.
+Merhaba Mehmet, hoş geldin.
+```
+
+Birden çok parametre virgülle ayrılır; değerler aynı sırayla verilir.
+
+```kbl
+fonksiyon fis_satiri(urun, adet, fiyat):
+    yazdir(f"{urun:<10}{adet:>3} x {fiyat:>6.2f}")
+
+fis_satiri("Ekmek", 2, 12.5)
+fis_satiri("Peynir", 1, 149.0)
+```
+```cikti
+Ekmek       2 x  12.50
+Peynir      1 x 149.00
+```
+
+## Değer döndürmek: don
+
+`don` sonucu çağıran yere geri verir. Dönen değeri bir değişkene atayabilir ya da doğrudan kullanabilirsin.
+
+```kbl
+fonksiyon kare(x):
+    don x * x
+
+alan = kare(7)
+yazdir(alan)
+yazdir(kare(3) + kare(4))
+```
+```cikti
+49
+25
+```
+
+`don` fonksiyonu orada bitirir; altındaki satırlar çalışmaz. Cevap belli olduğu anda çıkmak kodu sadeleştirir.
+
+```kbl
+fonksiyon not_harfi(puan):
+    eger puan >= 85:
+        don "AA"
+    eger puan >= 70:
+        don "BA"
+    eger puan >= 50:
+        don "CC"
+    don "FF"
+
+yazdir(not_harfi(92))
+yazdir(not_harfi(74))
+yazdir(not_harfi(31))
+```
+```cikti
+AA
+BA
+FF
+```
+
+## Fonksiyon fonksiyonu çağırabilir
+
+```kbl
+fonksiyon cift_mi(n):
+    don n % 2 == 0
+
+fonksiyon ciftleri_yaz(son):
+    dongu i icinde 1..son:
+        eger cift_mi(i):
+            konsol.yaz(f"{i} ")
+    yazdir()
+
+ciftleri_yaz(12)
+```
+```cikti
+2 4 6 8 10 12
+```
+
+> **Dikkat:** Fonksiyonun içinde, programın başka bir yerinde kullandığın değişken adlarını kullanmamaya özen göster; her fonksiyonun içinde kendine özgü adlar seç. İyi bir alışkanlık da şudur: fonksiyonlarını dosyanın başına yaz, programın asıl işini altlarına koy.
+
+## Gerçek bir örnek
+
+```kbl
+fonksiyon kdvli(fiyat):
+    don fiyat * 1.20
+
+fonksiyon fiyat_yaz(urun, fiyat):
+    yazdir(f"{urun}: {fiyat:.2f} TL (KDV dahil {kdvli(fiyat):.2f} TL)")
+
+fiyat_yaz("Kulaklık", 850.0)
+fiyat_yaz("Kılıf", 120.0)
+```
+```cikti
+Kulaklık: 850.00 TL (KDV dahil 1020.00 TL)
+Kılıf: 120.00 TL (KDV dahil 144.00 TL)
+```
+
+## Alıştırma
+
+```alistirma
+`cevre(en, boy)` adında, bir dikdörtgenin çevresini döndüren bir fonksiyon yaz. Sonra `cevre(5, 3)` ve `cevre(10, 10)` sonuçlarını ayrı satırlarda yazdır.
+%%%
+# buraya yaz
+
+yazdir(cevre(5, 3))
+yazdir(cevre(10, 10))
+%%%
+fonksiyon cevre(en, boy):
+    don 2 * (en + boy)
+
+yazdir(cevre(5, 3))
+yazdir(cevre(10, 10))
+%%%
+16
+40
+```
+
+```alistirma
+`buyuk_olan(a, b)` adında, iki sayıdan büyük olanı döndüren bir fonksiyon yaz. Sonra onu kullanarak üç sayının en büyüğünü bulup yazdır.
+%%%
+# buraya yaz
+
+yazdir(buyuk_olan(buyuk_olan(14, 27), 9))
+%%%
+fonksiyon buyuk_olan(a, b):
+    eger a > b:
+        don a
+    don b
+
+yazdir(buyuk_olan(buyuk_olan(14, 27), 9))
+%%%
+27
+```

dersler/20-parametreler-donus.md

@@ -0,0 +1,200 @@
+---
+baslik: Parametreler ve dönüş değeri
+bolum: Fonksiyonlar
+ozet: Tür belirtmek, varsayılan değer, adlı argüman, birden çok değer döndürmek
+---
+
+Fonksiyonlar büyüdükçe "bu parametreye ne vermeliyim?" sorusu önem kazanır. Türleri yazmak, varsayılan değer vermek ve adlı argüman kullanmak fonksiyonunu hem güvenli hem rahat kullanılır yapar.
+
+## Türleri yazmak
+
+Parametrenin türünü `ad: tur`, dönüş türünü `-> tur` ile yazarsın. Zorunlu değil ama yazarsan derleyici denetler.
+
+```kbl
+fonksiyon dikdortgen_alani(en: sayi, boy: sayi) -> sayi:
+    don en * boy
+
+fonksiyon ortalama(a: ondalik, b: ondalik) -> ondalik:
+    don (a + b) / 2.0
+
+yazdir(dikdortgen_alani(3, 4))
+yazdir(ortalama(72.0, 85.0))
+```
+```cikti
+12
+78.5
+```
+
+Yanlış türde değer verirsen program çalışmadan uyarılırsın:
+
+```kbl goster
+fonksiyon kare(x: sayi) -> sayi:
+    don x * x
+
+yazdir(kare("üç"))   # hata: 'x' parametresi 'sayi' bekler, 'metin' verildi
+```
+
+## Varsayılan değer
+
+Bir parametreye `= değer` ile varsayılan verirsen, çağıran o değeri yazmadığında varsayılan kullanılır. Varsayılanlı parametreler en sona yazılır.
+
+```kbl
+fonksiyon kdvli_fiyat(fiyat: ondalik, oran: sayi = 20) -> ondalik:
+    don fiyat * (1.0 + ondalik(oran) / 100.0)
+
+yazdir(f"{kdvli_fiyat(100.0):.2f}")
+yazdir(f"{kdvli_fiyat(100.0, 10):.2f}")
+```
+```cikti
+120.00
+110.00
+```
+
+## Adlı argüman
+
+Çağırırken parametrenin adını yazarsan kod daha okunur olur, sıra karışmaz.
+
+```kbl
+fonksiyon selamla(ad: metin, unvan: metin = "") -> metin:
+    eger unvan.bos_mu():
+        don f"Merhaba {ad}"
+    don f"Merhaba {unvan} {ad}"
+
+yazdir(selamla("Ayşe"))
+yazdir(selamla("Kaya", "Dr."))
+yazdir(selamla(ad="Can", unvan="Av."))
+```
+```cikti
+Merhaba Ayşe
+Merhaba Dr. Kaya
+Merhaba Av. Can
+```
+
+## Mantık döndüren fonksiyon
+
+Adı `_mi` ile biten, `dogru`/`yanlis` döndüren fonksiyonlar `eger` içinde çok doğal okunur.
+
+```kbl
+fonksiyon asal_mi(n: sayi) -> mantik:
+    eger n < 2:
+        don yanlis
+    bolen = 2
+    iken bolen * bolen <= n:
+        eger n % bolen == 0:
+            don yanlis
+        bolen += 1
+    don dogru
+
+dongu aday icinde [2, 9, 17, 21]:
+    eger asal_mi(aday):
+        yazdir(f"{aday} asaldır")
+    degilse:
+        yazdir(f"{aday} asal değildir")
+```
+```cikti
+2 asaldır
+9 asal değildir
+17 asaldır
+21 asal değildir
+```
+
+## Liste döndürmek
+
+Fonksiyon bir liste de döndürebilir.
+
+```kbl
+fonksiyon bolenler(n: sayi) -> liste<sayi>:
+    bulunan = []
+    dongu i icinde 1..n:
+        eger n % i == 0:
+            bulunan.ekle(i)
+    don bulunan
+
+yazdir(bolenler(36))
+```
+```cikti
+[1, 2, 3, 4, 6, 9, 12, 18, 36]
+```
+
+## Birden çok değer döndürmek
+
+`don a, b` iki değer döndürür; çağıran taraf `x, y = ...` ile ikisini birden alır.
+
+```kbl
+fonksiyon bol_ve_kalan(a: sayi, b: sayi):
+    don a // b, a % b
+
+bolum, kalan = bol_ve_kalan(17, 5)
+yazdir(f"17 = 5 x {bolum} + {kalan}")
+```
+```cikti
+17 = 5 x 3 + 2
+```
+
+## Fonksiyona verilen liste kopyalanır
+
+Fonksiyona bir liste verdiğinde fonksiyon onun **kopyasıyla** çalışır. İçeride yapılan değişiklik dışarıdaki listeyi etkilemez. Değişikliği görmek istiyorsan sonucu döndürüp yeniden atarsın.
+
+```kbl
+fonksiyon sifir_ekle(l: liste<sayi>) -> liste<sayi>:
+    l.ekle(0)
+    don l
+
+sayilar = [5, 6]
+yeni = sifir_ekle(sayilar)
+yazdir(sayilar)
+yazdir(yeni)
+sayilar = sifir_ekle(sayilar)
+yazdir(sayilar)
+```
+```cikti
+[5, 6]
+[5, 6, 0]
+[5, 6, 0]
+```
+
+> **Dikkat:** Bir fonksiyonun bütün `don` dalları aynı türü döndürmeli. Bir dalda `don 0`, başka dalda `don toplam / adet` (ondalık) yazarsan derleme hatası alırsın; o dalda `don 0.0` yaz.
+
+## Alıştırma
+
+```alistirma
+`indirimli(fiyat: ondalik, yuzde: sayi = 10) -> ondalik` fonksiyonunu yaz: fiyattan yüzde kadar indirim düşsün. `indirimli(200.0)` ve `indirimli(200.0, 25)` sonuçlarını 2 basamakla yazdır.
+%%%
+# buraya yaz
+
+yazdir(f"{indirimli(200.0):.2f}")
+yazdir(f"{indirimli(200.0, 25):.2f}")
+%%%
+fonksiyon indirimli(fiyat: ondalik, yuzde: sayi = 10) -> ondalik:
+    don fiyat - fiyat * ondalik(yuzde) / 100.0
+
+yazdir(f"{indirimli(200.0):.2f}")
+yazdir(f"{indirimli(200.0, 25):.2f}")
+%%%
+180.00
+150.00
+```
+
+```alistirma
+`en_kucuk_en_buyuk(l: liste<sayi>)` fonksiyonu listedeki en küçük ve en büyük değeri birlikte döndürsün. Sonucu iki değişkene alıp `3 - 41` biçiminde yazdır.
+%%%
+# buraya yaz
+
+kucuk, buyuk = en_kucuk_en_buyuk([17, 3, 41, 8])
+yazdir(f"{kucuk} - {buyuk}")
+%%%
+fonksiyon en_kucuk_en_buyuk(l: liste<sayi>):
+    enk = l[0]
+    enb = l[0]
+    dongu x icinde l:
+        eger x < enk:
+            enk = x
+        eger x > enb:
+            enb = x
+    don enk, enb
+
+kucuk, buyuk = en_kucuk_en_buyuk([17, 3, 41, 8])
+yazdir(f"{kucuk} - {buyuk}")
+%%%
+3 - 41
+```

dersler/21-ozyineleme.md

@@ -0,0 +1,172 @@
+---
+baslik: Özyineleme
+bolum: Fonksiyonlar
+ozet: Kendini çağıran fonksiyonlar, durma koşulu ve klasik örnekler
+---
+
+Bazı problemler kendisinin daha küçük bir kopyasını içerir: 5! = 5 × 4!, bir klasörün boyutu = içindeki dosyalar + alt klasörlerin boyutu. Böyle problemleri, kendini çağıran fonksiyonlarla (özyineleme) çok doğal çözersin.
+
+## Faktöriyel
+
+n! = n × (n-1)! ve 1! = 1. Fonksiyon kendini bir küçük sayıyla çağırır; n 1'e inince durur.
+
+```kbl
+fonksiyon faktoriyel(n: sayi) -> sayi:
+    eger n <= 1:
+        don 1
+    don n * faktoriyel(n - 1)
+
+yazdir(faktoriyel(5))
+yazdir(faktoriyel(10))
+```
+```cikti
+120
+3628800
+```
+
+Her özyinelemeli fonksiyonun iki parçası vardır:
+
+1. **Durma koşulu:** cevabın doğrudan bilindiği en küçük durum (`n <= 1` ise 1).
+2. **Küçülten adım:** problemi biraz küçültüp fonksiyonu yeniden çağırmak (`faktoriyel(n - 1)`).
+
+> **Dikkat:** Durma koşulunu unutursan ya da adım problemi küçültmezse fonksiyon kendini sonsuza dek çağırır ve program çöker. Her çağrının durma koşuluna biraz daha yaklaştığından emin ol.
+
+## Adım adım izlemek
+
+Ne olduğunu görmek için fonksiyonun içine `yazdir` koyalım.
+
+```kbl
+fonksiyon geri_say(n: sayi):
+    eger n == 0:
+        yazdir("Kalkış!")
+        don
+    yazdir(n)
+    geri_say(n - 1)
+
+geri_say(3)
+```
+```cikti
+3
+2
+1
+Kalkış!
+```
+
+Bu fonksiyon değer döndürmez; tek başına `don` yazmak fonksiyondan çıkmak demektir.
+
+## Basamakların toplamı
+
+4729 → 4 + 7 + 2 + 9. Son basamak `n % 10`, geri kalan `n // 10`'dur.
+
+```kbl
+fonksiyon basamak_toplami(n: sayi) -> sayi:
+    eger n < 10:
+        don n
+    don n % 10 + basamak_toplami(n // 10)
+
+yazdir(basamak_toplami(4729))
+```
+```cikti
+22
+```
+
+## Fibonacci
+
+Her sayı kendinden önceki iki sayının toplamıdır: 0, 1, 1, 2, 3, 5, 8...
+
+```kbl
+fonksiyon fib(n: sayi) -> sayi:
+    eger n < 2:
+        don n
+    don fib(n - 1) + fib(n - 2)
+
+dongu i icinde 0..10:
+    konsol.yaz(f"{fib(i)} ")
+yazdir()
+```
+```cikti
+0 1 1 2 3 5 8 13 21 34 55
+```
+
+> **İpucu:** Bu Fibonacci fonksiyonu aynı değerleri defalarca hesaplar; `fib(40)` gibi büyük değerlerde çok yavaşlar. Özyineleme her zaman en hızlı yol değildir; aynı işi bir `iken` döngüsüyle de yapabilirsin.
+
+## Metni ters çevirmek
+
+Özyineleme yalnız sayılarla çalışmaz. Bir metnin tersi = ilk harf hariç kalanın tersi + ilk harf.
+
+```kbl
+fonksiyon ters(m: metin) -> metin:
+    eger m.uzunluk() <= 1:
+        don m
+    don ters(m.dilim(1, m.uzunluk() - 1)) + m[0]
+
+yazdir(ters("kalem"))
+yazdir(ters("Ey Edip"))
+```
+```cikti
+melak
+pidE yE
+```
+
+## Hanoi kuleleri
+
+n diski A'dan C'ye taşımak için: n-1 diski B'ye taşı, en büyüğünü C'ye taşı, n-1 diski B'den C'ye taşı. Üç satırlık bir tanım, döngüyle yazması zor bir işi çözer.
+
+```kbl
+fonksiyon hanoi(n: sayi, kaynak: metin, hedef: metin, ara: metin):
+    eger n == 0:
+        don
+    hanoi(n - 1, kaynak, ara, hedef)
+    yazdir(f"{n}. diski {kaynak} → {hedef}")
+    hanoi(n - 1, ara, hedef, kaynak)
+
+hanoi(3, "A", "C", "B")
+```
+```cikti
+1. diski A → C
+2. diski A → B
+1. diski C → B
+3. diski A → C
+1. diski B → A
+2. diski B → C
+1. diski A → C
+```
+
+## Alıştırma
+
+```alistirma
+`us(taban: sayi, kuvvet: sayi) -> sayi` fonksiyonunu özyinelemeyle yaz: `us(t, 0)` 1'dir, `us(t, k)` ise `t * us(t, k - 1)`'dir. `us(2, 10)` ve `us(3, 4)` sonuçlarını yazdır.
+%%%
+# buraya yaz
+
+yazdir(us(2, 10))
+yazdir(us(3, 4))
+%%%
+fonksiyon us(taban: sayi, kuvvet: sayi) -> sayi:
+    eger kuvvet == 0:
+        don 1
+    don taban * us(taban, kuvvet - 1)
+
+yazdir(us(2, 10))
+yazdir(us(3, 4))
+%%%
+1024
+81
+```
+
+```alistirma
+`liste_toplami(l: liste<sayi>, i: sayi) -> sayi` fonksiyonunu özyinelemeyle yaz: listenin `i`'nci öğesinden sonuna kadar olan öğelerin toplamını döndürsün. `i` listenin uzunluğuna eşitse 0 döndür.
+%%%
+# buraya yaz
+
+yazdir(liste_toplami([4, 8, 15, 16, 23, 42], 0))
+%%%
+fonksiyon liste_toplami(l: liste<sayi>, i: sayi) -> sayi:
+    eger i == l.uzunluk():
+        don 0
+    don l[i] + liste_toplami(l, i + 1)
+
+yazdir(liste_toplami([4, 8, 15, 16, 23, 42], 0))
+%%%
+108
+```

dersler/22-yapilar.md

@@ -0,0 +1,210 @@
+---
+baslik: Yapılar
+bolum: Kendi türlerin
+ozet: yapi ile ilgili verileri tek bir türde toplamak
+---
+
+Bir kitabın adı, yazarı, sayfa sayısı ve yılı birbirine aittir. Bunları dört ayrı değişkende ya da dört ayrı listede tutmak çabuk karışır. `yapi` ile kendi türünü tanımlar, bu bilgileri tek bir değerde toplarsın.
+
+## Yapı tanımlamak
+
+Yapının her alanına bir varsayılan değer verirsin; alanın türü bu değerden anlaşılır.
+
+```kbl
+yapi Kitap:
+    ad = ""
+    yazar = ""
+    sayfa = 0
+    yil = 0
+
+k = Kitap("Kuyucaklı Yusuf", "Sabahattin Ali", 232, 1937)
+yazdir(k.ad)
+yazdir(k.sayfa)
+yazdir(k)
+```
+```cikti
+Kuyucaklı Yusuf
+232
+Kitap(ad: Kuyucaklı Yusuf, yazar: Sabahattin Ali, sayfa: 232, yil: 1937)
+```
+
+`Kitap(...)` yeni bir nesne oluşturur; değerler alanların tanım sırasıyla verilir. Alanlara `nesne.alan` diye ulaşırsın.
+
+## Nesne oluşturmanın yolları
+
+Boş bir nesne oluşturup alanları sonra da doldurabilir, ya da yalnız bazı alanları adıyla verebilirsin. Verilmeyen alanlar varsayılan değerinde kalır.
+
+```kbl
+yapi Kitap:
+    ad = ""
+    yazar = ""
+    sayfa = 0
+
+k1 = Kitap()
+k1.ad = "Çalıkuşu"
+k1.sayfa = 544
+yazdir(k1)
+
+k2 = Kitap(ad="İnce Memed", yazar="Yaşar Kemal")
+yazdir(k2)
+```
+```cikti
+Kitap(ad: Çalıkuşu, yazar: , sayfa: 544)
+Kitap(ad: İnce Memed, yazar: Yaşar Kemal, sayfa: 0)
+```
+
+## Metotlar
+
+Yapının içine fonksiyon yazabilirsin; bunlara **metot** denir. Yapı metotları alanlara doğrudan adıyla ulaşır.
+
+```kbl
+yapi Urun:
+    ad = ""
+    fiyat = 0.0
+    adet = 0
+
+    fonksiyon tutar() -> ondalik:
+        don fiyat * adet
+
+    fonksiyon etiket() -> metin:
+        don f"{ad} x{adet}: {tutar():.2f} TL"
+
+u = Urun("Defter", 24.5, 3)
+yazdir(u.tutar())
+yazdir(u.etiket())
+u.adet = 5
+yazdir(u.etiket())
+```
+```cikti
+73.5
+Defter x3: 73.50 TL
+Defter x5: 122.50 TL
+```
+
+## Nesne listesi
+
+Yapılar listelerde tutulabilir. Böylece bir tabloyu çok rahat işlersin.
+
+```kbl
+yapi Ogrenci:
+    ad = ""
+    puan = 0
+
+sinif_listesi = [Ogrenci("Ayşe", 88), Ogrenci("Mehmet", 64), Ogrenci("Elif", 92)]
+sinif_listesi.ekle(Ogrenci("Can", 47))
+
+en_iyi = sinif_listesi[0]
+dongu o icinde sinif_listesi:
+    durum = "geçti" eger o.puan >= 50 degilse "kaldı"
+    yazdir(f"{o.ad:<8}{o.puan:>4}  {durum}")
+    eger o.puan > en_iyi.puan:
+        en_iyi = o
+yazdir(f"En yüksek puan: {en_iyi.ad} ({en_iyi.puan})")
+```
+```cikti
+Ayşe      88  geçti
+Mehmet    64  geçti
+Elif      92  geçti
+Can       47  kaldı
+En yüksek puan: Elif (92)
+```
+
+## Karşılaştırmak
+
+İki yapı nesnesi, bütün alanları eşitse eşittir.
+
+```kbl
+yapi Nokta:
+    x = 0
+    y = 0
+
+a = Nokta(3, 4)
+b = Nokta(3, 4)
+c = Nokta(0, 4)
+yazdir(a == b)
+yazdir(a == c)
+```
+```cikti
+doğru
+yanlış
+```
+
+## Atama bir kopya oluşturur
+
+Bir yapı nesnesini başka bir değişkene atamak **kopyasını** oluşturur. Kopyayı değiştirmek aslını etkilemez.
+
+```kbl
+yapi Nokta:
+    x = 0
+    y = 0
+
+a = Nokta(1, 2)
+b = a
+b.x = 99
+yazdir(a.x)
+yazdir(b.x)
+```
+```cikti
+1
+99
+```
+
+> **Dikkat:** Aynı kural fonksiyonlar için de geçerli: bir fonksiyona yapı verirsen fonksiyon kopyasını değiştirir. Nesnenin kendisini değiştirmek istiyorsan işi yapının **metodu** olarak yaz (bir sonraki ders), ya da değiştirilmiş nesneyi döndürüp yeniden ata.
+
+> **İpucu:** Tür adlarını büyük harfle başlat (`Kitap`, `Ogrenci`); değişken adlarını küçük harfle. `Hata`, `Liste`, `Metin` gibi bazı adlar dilin kendi türlerine ayrılmıştır, onları seçme.
+
+## Alıştırma
+
+```alistirma
+`Dikdortgen` adında, `en` ve `boy` alanları (varsayılan 0) ile `alan()` ve `cevre()` metotları olan bir yapı tanımla. `Dikdortgen(6, 4)` için alanı ve çevreyi aynı satırda yazdır.
+%%%
+# buraya yaz
+
+d = Dikdortgen(6, 4)
+yazdir(d.alan(), d.cevre())
+%%%
+yapi Dikdortgen:
+    en = 0
+    boy = 0
+
+    fonksiyon alan() -> sayi:
+        don en * boy
+
+    fonksiyon cevre() -> sayi:
+        don 2 * (en + boy)
+
+d = Dikdortgen(6, 4)
+yazdir(d.alan(), d.cevre())
+%%%
+24 20
+```
+
+```alistirma
+Verilen `Film` yapısıyla bir liste oluşturulmuş. 1990'dan sonra çıkan filmlerin adlarını ve hepsinin toplam süresini yazdır.
+%%%
+yapi Film:
+    ad = ""
+    yil = 0
+    sure = 0
+
+filmler = [Film("Eşkıya", 1996, 128), Film("Selvi Boylum Al Yazmalım", 1977, 90), Film("Kış Uykusu", 2014, 196)]
+toplam_sure = 0
+# buraya yaz
+%%%
+yapi Film:
+    ad = ""
+    yil = 0
+    sure = 0
+
+filmler = [Film("Eşkıya", 1996, 128), Film("Selvi Boylum Al Yazmalım", 1977, 90), Film("Kış Uykusu", 2014, 196)]
+toplam_sure = 0
+dongu f icinde filmler:
+    eger f.yil > 1990:
+        yazdir(f.ad)
+    toplam_sure += f.sure
+yazdir(f"Toplam süre: {toplam_sure} dakika")
+%%%
+Eşkıya
+Kış Uykusu
+Toplam süre: 414 dakika
+```

dersler/23-siniflar.md

@@ -0,0 +1,231 @@
+---
+baslik: Sınıflar ve metotlar
+bolum: Kendi türlerin
+ozet: sinif, kurucu (kur), self ile metotlar ve kalıtım
+---
+
+Yapı veriyi bir arada tutar. Bir banka hesabı ise yalnız veri değildir: para yatırılır, çekilir, yetersiz bakiyede işlem reddedilir. Davranışı olan nesneler için `sinif` kullanırsın.
+
+## Sınıf, kurucu ve self
+
+`sinif` tanımı yapıya benzer. Farkları:
+
+- `fonksiyon kur(self, ...)` bir **kurucudur**: nesne oluşturulurken çalışır.
+- Metotların ilk parametresi `self`'tir: "bu nesnenin kendisi" demektir. Alanlara `self.alan` ile ulaşırsın.
+
+```kbl
+sinif Hesap:
+    sahip = ""
+    bakiye = 0.0
+
+    fonksiyon kur(self, kisi: metin, ilk: ondalik):
+        self.sahip = kisi
+        self.bakiye = ilk
+
+    fonksiyon yatir(self, miktar: ondalik):
+        self.bakiye += miktar
+
+    fonksiyon ozet(self) -> metin:
+        don f"{self.sahip}: {self.bakiye:.2f} TL"
+
+h = Hesap("Ayşe", 100.0)
+h.yatir(50.0)
+yazdir(h.ozet())
+```
+```cikti
+Ayşe: 150.00 TL
+```
+
+`Hesap("Ayşe", 100.0)` yazınca `kur(self, "Ayşe", 100.0)` çağrılır.
+
+## Metot nesneyi kalıcı olarak değiştirir
+
+Metot kendi nesnesinin alanlarını değiştirdiğinde değişiklik kalıcıdır. Bir metot ayrıca değer de döndürebilir.
+
+```kbl
+sinif Hesap:
+    bakiye = 0.0
+
+    fonksiyon kur(self, ilk: ondalik):
+        self.bakiye = ilk
+
+    fonksiyon cek(self, miktar: ondalik) -> mantik:
+        eger miktar > self.bakiye:
+            don yanlis
+        self.bakiye -= miktar
+        don dogru
+
+h = Hesap(100.0)
+yazdir(h.cek(30.0))
+yazdir(h.cek(500.0))
+yazdir(h.bakiye)
+```
+```cikti
+doğru
+yanlış
+70.0
+```
+
+## Her nesnenin kendi alanları vardır
+
+Aynı sınıftan oluşturulan nesneler birbirinden bağımsızdır.
+
+```kbl
+sinif Sayac:
+    adet = 0
+
+    fonksiyon kur(self, baslangic: sayi):
+        self.adet = baslangic
+
+    fonksiyon artir(self):
+        self.adet += 1
+
+a = Sayac(0)
+b = Sayac(10)
+a.artir()
+a.artir()
+b.artir()
+yazdir(f"a: {a.adet}, b: {b.adet}")
+```
+```cikti
+a: 2, b: 11
+```
+
+## Metot başka bir nesne alabilir
+
+```kbl
+yapi Kitap:
+    ad = ""
+    sayfa = 0
+
+sinif Okuyucu:
+    ad = ""
+    okunan_sayfa = 0
+    kitap_sayisi = 0
+
+    fonksiyon kur(self, isim: metin):
+        self.ad = isim
+
+    fonksiyon bitirdi(self, k: Kitap):
+        self.okunan_sayfa += k.sayfa
+        self.kitap_sayisi += 1
+
+    fonksiyon rapor(self) -> metin:
+        don f"{self.ad}: {self.kitap_sayisi} kitap, {self.okunan_sayfa} sayfa"
+
+elif = Okuyucu("Elif")
+elif.bitirdi(Kitap("Çalıkuşu", 544))
+elif.bitirdi(Kitap("Kuyucaklı Yusuf", 232))
+yazdir(elif.rapor())
+```
+```cikti
+Elif: 2 kitap, 776 sayfa
+```
+
+> **Dikkat:** Kurucunun adı mutlaka `kur`, ilk parametresi `self` olmalıdır. Parametre adını alanla aynı seçmek yerine farklı bir ad ver (`self.ad = isim`); kod daha kolay okunur.
+
+## Kalıtım
+
+Bir sınıf başka bir sınıfın alanlarını ve metotlarını devralabilir. Taban sınıfın adı parantez içinde yazılır. Türev sınıf bir metodu yeniden tanımlarsa (geçersiz kılma) kendi sürümü kullanılır.
+
+```kbl
+sinif Hayvan:
+    ad = ""
+
+    fonksiyon kur(self, isim: metin):
+        self.ad = isim
+
+    fonksiyon ses(self) -> metin:
+        don "..."
+
+    fonksiyon tanit(self) -> metin:
+        don f"Ben {self.ad}."
+
+sinif Kedi(Hayvan):
+    fonksiyon ses(self) -> metin:
+        don "Miyav!"
+
+k = Kedi("Tekir")
+yazdir(k.tanit())
+yazdir(k.ses())
+```
+```cikti
+Ben Tekir.
+Miyav!
+```
+
+`Kedi`'nin kendi `kur`'u yok; `Hayvan`'ınkini devraldı. `tanit` de devralındı, `ses` ise yeniden tanımlandı.
+
+> **İpucu:** Kalıtımda türev sınıfın kendi alanları ve kurucusu varsa, kurucusunun ilk satırında `ust.kur(...)` ile taban sınıfı kurar. Başlangıçta kalıtıma çok yaslanma; çoğu iş için yapılar ve basit sınıflar yeter.
+
+## Alıştırma
+
+```alistirma
+`Termometre` sınıfı yaz: `olcumler` alanı (boş sayı listesi, `liste<sayi> = []`), `ekle(self, d: sayi)` metodu ve ortalamayı döndüren `ortalama(self) -> ondalik` metodu olsun. Verilen ölçümlerle ortalamayı 1 basamakla yazdır.
+%%%
+# buraya yaz
+
+t = Termometre()
+t.ekle(18)
+t.ekle(24)
+t.ekle(27)
+yazdir(f"{t.ortalama():.1f}")
+%%%
+sinif Termometre:
+    olcumler: liste<sayi> = []
+
+    fonksiyon ekle(self, d: sayi):
+        self.olcumler.ekle(d)
+
+    fonksiyon ortalama(self) -> ondalik:
+        toplam = 0
+        dongu o icinde self.olcumler:
+            toplam += o
+        don toplam / self.olcumler.uzunluk()
+
+t = Termometre()
+t.ekle(18)
+t.ekle(24)
+t.ekle(27)
+yazdir(f"{t.ortalama():.1f}")
+%%%
+23.0
+```
+
+```alistirma
+Verilen `Hesap` sınıfına `cek(self, miktar: sayi) -> mantik` metodunu ekle: bakiye yetmezse `yanlis` döndürsün ve bakiyeye dokunmasın. Programın çıktısı aşağıdaki gibi olmalı.
+%%%
+sinif Hesap:
+    bakiye = 0
+
+    fonksiyon kur(self, ilk: sayi):
+        self.bakiye = ilk
+
+    # buraya yaz
+
+h = Hesap(200)
+yazdir(h.cek(150))
+yazdir(h.cek(100))
+yazdir(h.bakiye)
+%%%
+sinif Hesap:
+    bakiye = 0
+
+    fonksiyon kur(self, ilk: sayi):
+        self.bakiye = ilk
+
+    fonksiyon cek(self, miktar: sayi) -> mantik:
+        eger miktar > self.bakiye:
+            don yanlis
+        self.bakiye -= miktar
+        don dogru
+
+h = Hesap(200)
+yazdir(h.cek(150))
+yazdir(h.cek(100))
+yazdir(h.bakiye)
+%%%
+doğru
+yanlış
+50
+```

dersler/24-sayilabilir.md

@@ -0,0 +1,158 @@
+---
+baslik: Sayılabilir türler
+bolum: Kendi türlerin
+ozet: sayilabilir ile sınırlı seçenekleri güvenle tutmak
+---
+
+Bir siparişin durumu "hazırlanıyor", "kargoda" ya da "teslim edildi" olabilir; başka bir şey olamaz. Bunu metinle tutarsan bir gün biri `"kargda"` yazar ve hata gözden kaçar. `sayilabilir`, bir değişkenin alabileceği değerleri baştan sayar; yanlış yazılan bir değer program çalışmadan yakalanır.
+
+## Tanımlamak ve kullanmak
+
+Her üye kendi satırına yazılır. Üyeye `Tur.UYE` diye ulaşırsın.
+
+```kbl
+sayilabilir Durum:
+    HAZIRLANIYOR
+    KARGODA
+    TESLIM_EDILDI
+
+siparis = Durum.KARGODA
+yazdir(siparis)
+eger siparis == Durum.KARGODA:
+    yazdir("Siparişin yolda.")
+```
+```cikti
+KARGODA
+Siparişin yolda.
+```
+
+Yazdırınca üyenin adı görünür.
+
+## Yanlış üye derlenmez
+
+```kbl goster
+sayilabilir Renk:
+    KIRMIZI
+    MAVI
+
+r = Renk.MOR     # derleme hatası: Renk'in MOR diye bir üyesi yok
+```
+
+Bu, sayılabilir türlerin asıl yararıdır: yazım hatası programın çalıştığı ana değil, derlendiği ana yakalanır.
+
+## Seçeneğe göre karar vermek
+
+Sayılabilir değerler `eger / degilse eger` ile çok iyi anlaşır. Bir trafik ışığının sıradaki rengini bulalım.
+
+```kbl
+sayilabilir Isik:
+    KIRMIZI
+    SARI
+    YESIL
+
+fonksiyon sonraki(i: Isik) -> Isik:
+    eger i == Isik.KIRMIZI:
+        don Isik.YESIL
+    degilse eger i == Isik.YESIL:
+        don Isik.SARI
+    don Isik.KIRMIZI
+
+isik = Isik.KIRMIZI
+dongu adim icinde 1..4:
+    yazdir(isik)
+    isik = sonraki(isik)
+```
+```cikti
+KIRMIZI
+YESIL
+SARI
+KIRMIZI
+```
+
+## Üyelerin sayı değerleri
+
+Her üyenin arkasında bir sayı vardır. İlk üye 0'dan başlar; istersen değeri kendin verirsin. Değer yazılmayan üye bir öncekinden devam eder. `sayi()` ile bu değeri alırsın.
+
+```kbl
+sayilabilir Oncelik:
+    DUSUK = 1
+    ORTA
+    YUKSEK = 10
+
+yazdir(sayi(Oncelik.DUSUK))
+yazdir(sayi(Oncelik.ORTA))
+yazdir(sayi(Oncelik.YUKSEK))
+yazdir(Oncelik.YUKSEK > Oncelik.ORTA)
+```
+```cikti
+1
+2
+10
+doğru
+```
+
+## Yapı alanı ve liste öğesi olarak
+
+Sayılabilir bir değer yapının alanı ya da listenin öğesi olabilir.
+
+```kbl
+sayilabilir Tur:
+    KEDI
+    KOPEK
+    KUS
+
+yapi Hayvan:
+    ad = ""
+    tur = Tur.KEDI
+
+barinak = [Hayvan("Pamuk", Tur.KEDI), Hayvan("Karabaş", Tur.KOPEK), Hayvan("Maviş", Tur.KUS), Hayvan("Tekir", Tur.KEDI)]
+kedi_sayisi = 0
+dongu h icinde barinak:
+    yazdir(f"{h.ad:<8}{h.tur}")
+    eger h.tur == Tur.KEDI:
+        kedi_sayisi += 1
+yazdir(f"{kedi_sayisi} kedi var.")
+```
+```cikti
+Pamuk   KEDI
+Karabaş KOPEK
+Maviş   KUS
+Tekir   KEDI
+2 kedi var.
+```
+
+> **Dikkat:** Sözlük değerleri sayılabilir tutamaz: `{"a": Tur.KEDI}` derlenmez. Böyle bir eşleme gerekiyorsa değeri bir yapının alanında tut.
+
+## Alıştırma
+
+```alistirma
+`Mevsim` adında `ILKBAHAR`, `YAZ`, `SONBAHAR`, `KIS` üyeli bir sayılabilir tür tanımla. `mevsim_bul(ay: sayi) -> Mevsim` fonksiyonu ay numarasına göre mevsimi döndürsün (12, 1, 2 kış; 3-5 ilkbahar; 6-8 yaz; 9-11 sonbahar). Verilen aylar için sonucu yazdır.
+%%%
+# buraya yaz
+
+dongu ay icinde [1, 4, 7, 10]:
+    yazdir(mevsim_bul(ay))
+%%%
+sayilabilir Mevsim:
+    ILKBAHAR
+    YAZ
+    SONBAHAR
+    KIS
+
+fonksiyon mevsim_bul(ay: sayi) -> Mevsim:
+    eger ay >= 3 ve ay <= 5:
+        don Mevsim.ILKBAHAR
+    degilse eger ay >= 6 ve ay <= 8:
+        don Mevsim.YAZ
+    degilse eger ay >= 9 ve ay <= 11:
+        don Mevsim.SONBAHAR
+    don Mevsim.KIS
+
+dongu ay icinde [1, 4, 7, 10]:
+    yazdir(mevsim_bul(ay))
+%%%
+KIS
+ILKBAHAR
+YAZ
+SONBAHAR
+```

dersler/25-hata-yonetimi.md

@@ -0,0 +1,217 @@
+---
+baslik: Hata yönetimi: sonuc ve ?
+bolum: Hatalar ve dosyalar
+ozet: Başarı ya da hata döndüren fonksiyonlar, ? ile hata iletmek ve belki
+---
+
+Programlar her zaman yolunda gitmez: kullanıcı yaş yerine "otuz" yazar, bir sayı sıfıra bölünür, aranan kayıt bulunamaz. KabaLang'de beklenebilir hatalar **dönüş değeriyle** bildirilir: fonksiyon ya başarıyı ya da hatayı döndürür ve çağıran taraf ikisini de ele almak zorundadır.
+
+## sonuc: başarı ya da hata
+
+Dönüş türü `sonuc<sayi, Hata>` olan bir fonksiyon başarıda `tamam(deger)`, başarısızlıkta `hata("mesaj")` döndürür.
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+r = bol(20, 4)
+eger r.tamam_mi():
+    yazdir(f"Sonuç: {r.deger()}")
+
+h = bol(5, 0)
+eger h.hatali_mi():
+    yazdir("Hata: " + h.hata().mesaj())
+```
+```cikti
+Sonuç: 5
+Hata: sıfıra bölünemez
+```
+
+| Yazım | Anlamı |
+|---|---|
+| `tamam(deger)` | başarı döndür |
+| `hata("mesaj")` | hata döndür |
+| `.tamam_mi()` / `.hatali_mi()` | hangisi olduğunu sor |
+| `.deger()` | başarıdaki değeri al |
+| `.hata().mesaj()` | hatanın açıklamasını al |
+| `.deger_veya(yedek)` | hata varsa yedek değeri ver |
+
+## Yedek değerle devam etmek
+
+Hatanın nedeni seni ilgilendirmiyorsa `deger_veya()` ile bir yedek değer verirsin.
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+yazdir(bol(20, 4).deger_veya(0))
+yazdir(bol(20, 0).deger_veya(0))
+```
+```cikti
+5
+0
+```
+
+## Girdiyi denetleyen bir fonksiyon
+
+Kullanıcıdan gelen bir yaşı denetleyelim: boş olmasın, yalnız rakam içersin, gerçekçi olsun.
+
+```kbl
+fonksiyon yas_coz(girdi: metin) -> sonuc<sayi, Hata>:
+    temiz = girdi.kirp()
+    eger temiz.bos_mu():
+        don hata("yaş boş bırakılamaz")
+    dongu harf icinde temiz:
+        eger degil "0123456789".icerir(harf):
+            don hata(f"'{temiz}' bir sayı değil")
+    yas = sayi(temiz)
+    eger yas > 130:
+        don hata(f"{yas} yaş gerçekçi değil")
+    don tamam(yas)
+
+dongu g icinde ["34", " 7 ", "", "otuz", "250"]:
+    r = yas_coz(g)
+    eger r.tamam_mi():
+        yazdir(f"✓ {r.deger()}")
+    degilse:
+        yazdir(f"✗ {r.hata().mesaj()}")
+```
+```cikti
+✓ 34
+✓ 7
+✗ yaş boş bırakılamaz
+✗ 'otuz' bir sayı değil
+✗ 250 yaş gerçekçi değil
+```
+
+## ? ile hatayı yukarı iletmek
+
+Her çağrıdan sonra `eger hatali_mi()` yazmak yorucudur. Çağrının sonuna `?` koyarsan şu anlama gelir: "hata varsa bu fonksiyondan da aynı hatayla hemen çık; yoksa içindeki değeri ver."
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+fonksiyon kisi_basi(toplam: sayi, kisi: sayi, gun: sayi) -> sonuc<sayi, Hata>:
+    kisi_payi = bol(toplam, kisi)?
+    gunluk = bol(kisi_payi, gun)?
+    don tamam(gunluk)
+
+yazdir(kisi_basi(12000, 4, 5).deger())
+yazdir(kisi_basi(12000, 0, 5).hata().mesaj())
+```
+```cikti
+600
+sıfıra bölünemez
+```
+
+> **Dikkat:** `?`'yi yalnız dönüş türü kendisi de `sonuc` olan bir fonksiyonun içinde kullan. Hata ancak o zaman yukarı iletilebilir; programın ana akışında ya da dönüş türü olmayan bir fonksiyonda `?` yerine `tamam_mi()` / `deger_veya()` kullan.
+
+## Sonucu yok saymak yasaktır
+
+`sonuc` döndüren bir fonksiyonu çağırıp sonucu hiç kullanmazsan program derlenmez.
+
+```kbl goster
+fonksiyon kaydet() -> sonuc<sayi, Hata>:
+    don tamam(1)
+
+kaydet()    # hata: bu çağrı bir 'sonuc' döndürüyor ve sonuç yok sayılıyor
+```
+
+Sonucu bilerek atmak istiyorsan bunu açıkça yazarsın: `_ = kaydet()`.
+
+## belki: değer var ya da yok
+
+Hatanın bir nedeni yoksa, yalnız "bulundu / bulunamadı" ayrımı gerekiyorsa `belki<T>` kullanılır: `dolu(deger)` ya da `bos`.
+
+```kbl
+fonksiyon ilk_uzun_kelime(kelimeler: liste<metin>, en_az: sayi) -> belki<metin>:
+    dongu k icinde kelimeler:
+        eger k.uzunluk() >= en_az:
+            don dolu(k)
+    don bos
+
+liste_ = ["kar", "yağmur", "fırtına"]
+b = ilk_uzun_kelime(liste_, 6)
+eger b.var_mi():
+    yazdir(b.deger())
+yazdir(ilk_uzun_kelime(liste_, 10).deger_veya("yok"))
+```
+```cikti
+yağmur
+yok
+```
+
+## Alıştırma
+
+```alistirma
+`karekok_tam(n: sayi) -> sonuc<sayi, Hata>` fonksiyonunu yaz: n negatifse `"negatif sayının karekökü yok"` hatası döndürsün; değilse karesi n'yi geçmeyen en büyük tam sayıyı (`k * k <= n` olan en büyük k) döndürsün. Verilen değerler için sonucu ya da hata mesajını yazdır.
+%%%
+# buraya yaz
+
+dongu n icinde [49, 50, -4]:
+    r = karekok_tam(n)
+    eger r.tamam_mi():
+        yazdir(r.deger())
+    degilse:
+        yazdir(r.hata().mesaj())
+%%%
+fonksiyon karekok_tam(n: sayi) -> sonuc<sayi, Hata>:
+    eger n < 0:
+        don hata("negatif sayının karekökü yok")
+    k = 0
+    iken (k + 1) * (k + 1) <= n:
+        k += 1
+    don tamam(k)
+
+dongu n icinde [49, 50, -4]:
+    r = karekok_tam(n)
+    eger r.tamam_mi():
+        yazdir(r.deger())
+    degilse:
+        yazdir(r.hata().mesaj())
+%%%
+7
+7
+negatif sayının karekökü yok
+```
+
+```alistirma
+Verilen `stok_bul` fonksiyonunu kullanan `toplam_stok(a: metin, b: metin) -> sonuc<sayi, Hata>` fonksiyonunu `?` ile yaz: iki ürünün stoklarını toplayıp döndürsün.
+%%%
+fonksiyon stok_bul(urun: metin) -> sonuc<sayi, Hata>:
+    eger urun == "kalem":
+        don tamam(40)
+    eger urun == "defter":
+        don tamam(25)
+    don hata(f"{urun} bulunamadı")
+
+# buraya yaz
+
+yazdir(toplam_stok("kalem", "defter").deger())
+yazdir(toplam_stok("kalem", "silgi").hata().mesaj())
+%%%
+fonksiyon stok_bul(urun: metin) -> sonuc<sayi, Hata>:
+    eger urun == "kalem":
+        don tamam(40)
+    eger urun == "defter":
+        don tamam(25)
+    don hata(f"{urun} bulunamadı")
+
+fonksiyon toplam_stok(a: metin, b: metin) -> sonuc<sayi, Hata>:
+    x = stok_bul(a)?
+    y = stok_bul(b)?
+    don tamam(x + y)
+
+yazdir(toplam_stok("kalem", "defter").deger())
+yazdir(toplam_stok("kalem", "silgi").hata().mesaj())
+%%%
+65
+silgi bulunamadı
+```

dersler/26-istisnalar.md

@@ -0,0 +1,157 @@
+---
+baslik: Hata yakalama: dene ve yakala
+bolum: Hatalar ve dosyalar
+ozet: firlat, dene, yakala ve sonunda ile beklenmeyen durumlar
+---
+
+`sonuc` beklenebilir hatalar içindir. Bazı durumlarda ise program o noktada devam edemez: stokta olmayan bir ürün satılmaya çalışılır, listede olmayan bir sıra istenir. Böyle durumlarda hata **fırlatılır**; onu yakalayan bir `dene` bloğu yoksa program durur.
+
+## dene ve yakala
+
+`dene` bloğunda bir hata fırlatılırsa blok orada kesilir ve `yakala` bloğu çalışır. `yakala h:` hata mesajını `h` adıyla verir.
+
+```kbl
+dene:
+    yazdir("İşlem başlıyor")
+    firlat "bağlantı kurulamadı"
+    yazdir("Bu satır çalışmaz")
+yakala h:
+    yazdir("Yakalandı: " + h)
+yazdir("Program devam ediyor")
+```
+```cikti
+İşlem başlıyor
+Yakalandı: bağlantı kurulamadı
+Program devam ediyor
+```
+
+Hata olmazsa `yakala` bloğu hiç çalışmaz.
+
+## Fonksiyondan hata fırlatmak
+
+`firlat hata("mesaj")` fonksiyonu orada bitirir; hata, onu yakalayan ilk `dene` bloğuna kadar çıkar.
+
+```kbl
+fonksiyon stoktan_dus(stok: sayi, adet: sayi) -> sayi:
+    eger adet <= 0:
+        firlat hata(f"geçersiz adet: {adet}")
+    eger adet > stok:
+        firlat hata(f"stokta {stok} ürün var, {adet} istendi")
+    don stok - adet
+
+kalan = 10
+dongu istek icinde [3, 4, 0, 5]:
+    dene:
+        kalan = stoktan_dus(kalan, istek)
+        yazdir(f"{istek} adet satıldı, {kalan} kaldı")
+    yakala h:
+        yazdir(f"Satış yapılamadı: {h}")
+```
+```cikti
+3 adet satıldı, 7 kaldı
+4 adet satıldı, 3 kaldı
+Satış yapılamadı: geçersiz adet: 0
+Satış yapılamadı: stokta 3 ürün var, 5 istendi
+```
+
+## Dilin kendi fırlattığı hatalar
+
+Sıfıra bölme, listede olmayan bir sıra, sözlükte olmayan bir anahtar... Bunlar da fırlatılan hatalardır. Yakalanırlarsa program devam eder.
+
+```kbl
+sehirler = ["Rize", "Artvin"]
+dene:
+    yazdir(sehirler[5])
+yakala:
+    yazdir("Listede 5. sırada şehir yok.")
+
+bolen = 0
+dene:
+    yazdir(100 // bolen)
+yakala:
+    yazdir("Sıfıra bölme yakalandı.")
+```
+```cikti
+Listede 5. sırada şehir yok.
+Sıfıra bölme yakalandı.
+```
+
+`yakala`'dan sonra ad yazmazsan hata mesajı kullanılmaz, yalnız yakalanır.
+
+> **Dikkat:** Yakalanmayan bir hata programı o satırda durdurur ve altındaki hiçbir şey çalışmaz. Ama her şeyi `dene` içine sarmak da hatayı gizler. Beklenen durumlar (geçersiz girdi gibi) için `sonuc`, gerçekten olağandışı durumlar için `firlat` kullan.
+
+## sonunda: her durumda çalışan blok
+
+`sonunda:` bloğu, hata olsa da olmasa da en son çalışır. Temizlik işleri (dosyayı kapatmak, "işlem bitti" demek) için kullanılır.
+
+```kbl
+dongu bolen icinde [5, 0]:
+    dene:
+        yazdir(f"100 / {bolen} = {100 // bolen}")
+    yakala:
+        yazdir("bölme yapılamadı")
+    sonunda:
+        yazdir("--- işlem tamam")
+```
+```cikti
+100 / 5 = 20
+--- işlem tamam
+bölme yapılamadı
+--- işlem tamam
+```
+
+## Hangi yolu seçmeli?
+
+| Durum | Yol |
+|---|---|
+| Kullanıcı yanlış değer girdi, kayıt bulunamadı | `sonuc` / `belki` döndür |
+| Programın o noktada devam etmesi anlamsız | `firlat` |
+| Bir hatayı yakalayıp programı sürdürmek | `dene` / `yakala` |
+
+## Alıştırma
+
+```alistirma
+`yas_kontrol(yas: sayi) -> sayi` fonksiyonu yaş 0'dan küçükse `"yaş negatif olamaz"` hatası fırlatsın, değilse yaşı döndürsün. Verilen her yaş için `dene/yakala` ile ya `Yaş: 25` ya da `Hata: yaş negatif olamaz` yazdır.
+%%%
+# buraya yaz
+
+dongu y icinde [25, -3]:
+    dene:
+        yazdir(f"Yaş: {yas_kontrol(y)}")
+    yakala h:
+        yazdir(f"Hata: {h}")
+%%%
+fonksiyon yas_kontrol(yas: sayi) -> sayi:
+    eger yas < 0:
+        firlat hata("yaş negatif olamaz")
+    don yas
+
+dongu y icinde [25, -3]:
+    dene:
+        yazdir(f"Yaş: {yas_kontrol(y)}")
+    yakala h:
+        yazdir(f"Hata: {h}")
+%%%
+Yaş: 25
+Hata: yaş negatif olamaz
+```
+
+```alistirma
+`fiyat` sözlüğünde olmayan bir ürünü okumak hata fırlatır. `sepet` listesindeki her ürün için `dene/yakala` ile fiyatı yazdır; bulunamayan ürün için `muz: fiyat yok` yaz.
+%%%
+fiyat = {"elma": 30, "armut": 45}
+sepet = ["elma", "muz", "armut"]
+# buraya yaz
+%%%
+fiyat = {"elma": 30, "armut": 45}
+sepet = ["elma", "muz", "armut"]
+dongu urun icinde sepet:
+    dene:
+        yazdir(f"{urun}: {fiyat[urun]} TL")
+    yakala:
+        yazdir(f"{urun}: fiyat yok")
+%%%
+elma: 30 TL
+muz: fiyat yok
+armut: 45 TL
+```

dersler/27-kullanici-girdisi.md

@@ -0,0 +1,161 @@
+---
+baslik: Kullanıcıdan girdi
+bolum: Hatalar ve dosyalar
+ozet: konsol.satir_oku ve konsol.sayi_oku ile klavyeden okumak
+---
+
+Şimdiye kadar bütün değerleri koda kendin yazdın. Gerçek programlar kullanıcıyla konuşur: adını sorar, bir sayı ister, cevaba göre davranır. Bunun için `konsol` modülünü kullanırsın.
+
+> **Not:** Bu dersteki örneklerin altında bir **girdi** bloğu var: oradaki satırlar, kullanıcı klavyeden yazıp Enter'a basmış gibi programa verilir. Bu yüzden çıktıda yazılan cevap da görünür.
+
+## Bir satır okumak
+
+`kullan kaba.sistem` yazıp `konsol.satir_oku()` ile bir satır okursun. `konsol.yaz()` soruyu yazar ama satırı bitirmez; cevap sorunun yanında görünür.
+
+```kbl
+kullan kaba.sistem
+konsol.yaz("Adın: ")
+ad = konsol.satir_oku().deger_veya("misafir").kirp()
+yazdir(f"Merhaba {ad}!")
+```
+```girdi
+Ayşe
+```
+```cikti
+Adın: Ayşe
+Merhaba Ayşe!
+```
+
+`satir_oku()` bir `belki<metin>` döndürür: girdi bitmişse ortada okunacak satır yoktur. `deger_veya("misafir")` satır varsa onu, yoksa `"misafir"`i verir. `kirp()` ise baştaki ve sondaki boşlukları atar.
+
+## Sayı okumak
+
+`konsol.sayi_oku("soru")` soruyu yazar, satırı okur ve tam sayıya çevirmeyi dener. Sonuç bir `sonuc`'tur: ya sayı ya hata.
+
+```kbl
+kullan kaba.sistem
+r = konsol.sayi_oku("Doğum yılın: ")
+eger r.tamam_mi():
+    yazdir(f"2026'da {2026 - r.deger()} yaşına giriyorsun.")
+degilse:
+    yazdir("Okunamadı: " + r.hata().mesaj())
+```
+```girdi
+2011
+```
+```cikti
+Doğum yılın: 2011
+2026'da 15 yaşına giriyorsun.
+```
+
+Kullanıcı sayı yerine yazı girerse program çökmez; hatayı sen ele alırsın.
+
+```kbl
+kullan kaba.sistem
+r = konsol.sayi_oku("Kaç kitap okudun? ")
+eger r.tamam_mi():
+    yazdir(f"{r.deger()} kitap, harika!")
+degilse:
+    yazdir("Okunamadı: " + r.hata().mesaj())
+```
+```girdi
+on iki
+```
+```cikti
+Kaç kitap okudun? on iki
+Okunamadı: 'on iki' bir tam sayı değil
+```
+
+> **Dikkat:** Kullanıcıdan gelen sayıyı `sayi(satir)` ile çevirme: `sayi("on iki")` hata vermez, sessizce 0 döndürür. Tam sayı için `konsol.sayi_oku` kullan; böylece yanlış girdiyi fark edersin.
+
+## Ondalık sayı okumak
+
+Ondalık sayı için satırı okuyup `ondalik()` ile çevirirsin.
+
+```kbl
+kullan kaba.sistem
+konsol.yaz("Boyun (m): ")
+boy = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+konsol.yaz("Kilon (kg): ")
+kilo = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+yazdir(f"Vücut kitle indeksin: {kilo / (boy * boy):.1f}")
+```
+```girdi
+1.70
+65
+```
+```cikti
+Boyun (m): 1.70
+Kilon (kg): 65
+Vücut kitle indeksin: 22.5
+```
+
+## Birden çok girdi: küçük bir hesap makinesi
+
+```kbl
+kullan kaba.sistem
+a = konsol.sayi_oku("Birinci sayı: ").deger_veya(0)
+b = konsol.sayi_oku("İkinci sayı: ").deger_veya(0)
+yazdir(f"{a} + {b} = {a + b}")
+yazdir(f"{a} x {b} = {a * b}")
+```
+```girdi
+12
+7
+```
+```cikti
+Birinci sayı: 12
+İkinci sayı: 7
+12 + 7 = 19
+12 x 7 = 84
+```
+
+> **İpucu:** Örneği **Dene** ile açıp kendi sayılarınla çalıştır. Girdi okuyan programlarda IDE senden cevap bekler.
+
+## Alıştırma
+
+Alıştırmalar girdi verilmeden denetlendiği için burada klavyeden okumak yerine, kullanıcının yazdığı satırların bir listede durduğunu varsayıyoruz. Okuma kısmını örneklerde **Dene** ile kendin dene.
+
+```alistirma
+`girdiler` listesi kullanıcının yazdığı satırları tutuyor; satırlarda fazladan boşluk olabilir. Her satırı temizle ve şehir adını büyük harfle `İZMİR'den selam!` biçiminde yazdır.
+%%%
+girdiler = ["  İzmir ", "rize", " Iğdır"]
+dongu satir icinde girdiler:
+    # buraya yaz
+%%%
+girdiler = ["  İzmir ", "rize", " Iğdır"]
+dongu satir icinde girdiler:
+    sehir = satir.kirp()
+    yazdir(f"{sehir.buyut()}'den selam!")
+%%%
+İZMİR'den selam!
+RİZE'den selam!
+IĞDIR'den selam!
+```
+
+```alistirma
+`girdiler` listesindeki her satır bir yaş olmalı. Yalnız rakamlardan oluşan satırları sayıya çevirip topla; geçersiz satırlar için tırnak içinde `geçersiz: 'on beş'` biçiminde yazdır. En sonda toplamı yazdır.
+%%%
+girdiler = ["14", "on beş", "16", "", "17a"]
+toplam = 0
+# buraya yaz
+yazdir(f"Toplam: {toplam}")
+%%%
+girdiler = ["14", "on beş", "16", "", "17a"]
+toplam = 0
+dongu satir icinde girdiler:
+    gecerli = degil satir.bos_mu()
+    dongu harf icinde satir:
+        eger degil "0123456789".icerir(harf):
+            gecerli = yanlis
+    eger gecerli:
+        toplam += sayi(satir)
+    degilse:
+        yazdir(f"geçersiz: '{satir}'")
+yazdir(f"Toplam: {toplam}")
+%%%
+geçersiz: 'on beş'
+geçersiz: ''
+geçersiz: '17a'
+Toplam: 30
+```

dersler/28-dosyalar.md

@@ -0,0 +1,135 @@
+---
+baslik: Dosyalar
+bolum: Hatalar ve dosyalar
+ozet: Dosyaya yazmak, sonuna eklemek, geri okumak ve JSON ile saklamak
+---
+
+Program bittiğinde değişkenlerdeki her şey kaybolur. Bilgiyi saklamak için dosyaya yazarsın; program bir sonraki çalışmada onu geri okuyabilir. Dosya işlemleri `dosya` modülündedir; `kullan kaba.sistem` ile gelir.
+
+> **Not:** Bu dersteki örnekler çalıştıkları klasörde dosya oluşturur. Her örnek önce yazar, sonra aynı programda geri okur.
+
+## Yazmak ve okumak
+
+`dosya.yaz(yol, metin)` dosyayı oluşturur; dosya varsa içeriğini **silip** yeniden yazar. `dosya.oku(yol)` bütün dosyayı tek bir metin olarak verir.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("selam.txt", "Merhaba dosya!\n")
+icerik = dosya.oku("selam.txt")
+yazdir(icerik)
+```
+```cikti
+Merhaba dosya!
+```
+
+Her satırın sonuna `\n` koyarsın; yoksa satırlar yan yana birleşir.
+
+## Sonuna eklemek
+
+`dosya.ekle(yol, metin)` var olan içeriğe dokunmadan sonuna ekler.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("gunluk.txt", "Pazartesi: 5 km koştum\n")
+dosya.ekle("gunluk.txt", "Salı: dinlendim\n")
+dosya.ekle("gunluk.txt", "Çarşamba: 7 km koştum\n")
+yazdir(dosya.oku("gunluk.txt"))
+```
+```cikti
+Pazartesi: 5 km koştum
+Salı: dinlendim
+Çarşamba: 7 km koştum
+```
+
+> **Dikkat:** Bir kayıt eklemek istiyorken `dosya.yaz` kullanırsan dosyadaki eski her şey silinir. Eklemek için `dosya.ekle` kullan.
+
+## Satır satır işlemek
+
+Okuduğun metni `kirp()` ile sondaki `\n`'den arındırıp `bol("\n")` ile satırlara ayırırsın. Her satırı da `;` gibi bir ayraçla bölüp alanlara ulaşırsın.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("alisveris.txt", "ekmek;2;12.50\n")
+dosya.ekle("alisveris.txt", "süt;1;34.90\n")
+dosya.ekle("alisveris.txt", "domates;3;18.75\n")
+
+toplam = 0.0
+dongu satir icinde dosya.oku("alisveris.txt").kirp().bol("\n"):
+    parca = satir.bol(";")
+    adet = sayi(parca[1])
+    tutar = adet * ondalik(parca[2])
+    toplam += tutar
+    yazdir(f"{parca[0]:<10}{adet:>3}{tutar:>9.2f}")
+yazdir(f"{'Toplam':<13}{toplam:>9.2f} TL")
+```
+```cikti
+ekmek       2    25.00
+süt         1    34.90
+domates     3    56.25
+Toplam          116.15 TL
+```
+
+## Dosya var mı?
+
+Olmayan bir dosyayı okumak hata vermez, boş metin döndürür. Bu yüzden önce `dosya.var_mi()` ile sorarsın. `dosya.sil()` dosyayı siler.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("gecici.txt", "deneme\n")
+yazdir(dosya.var_mi("gecici.txt"))
+dosya.sil("gecici.txt")
+yazdir(dosya.var_mi("gecici.txt"))
+
+eger degil dosya.var_mi("ayarlar.txt"):
+    yazdir("ayarlar.txt yok, varsayılanlar kullanılacak.")
+```
+```cikti
+doğru
+yanlış
+ayarlar.txt yok, varsayılanlar kullanılacak.
+```
+
+## JSON ile saklamak
+
+JSON, sözlük ve listeleri metne çevirmenin yaygın bir biçimidir; başka programlar da okuyabilir. `json.uret()` bir sözlüğü metne çevirir, `json.coz()` metni geri çözer.
+
+```kbl
+kullan kaba.sistem
+ayarlar = {"tema": "koyu", "yazi_boyutu": 14}
+dosya.yaz("ayarlar.json", json.uret(ayarlar))
+yazdir(dosya.oku("ayarlar.json"))
+
+okunan = json.coz(dosya.oku("ayarlar.json"))
+yazdir(f"Tema: {metin(okunan['tema'])}")
+yazdir(f"Yazı boyutu + 2: {sayi(okunan['yazi_boyutu']) + 2}")
+```
+```cikti
+{"tema":"koyu","yazi_boyutu":14}
+Tema: koyu
+Yazı boyutu + 2: 16
+```
+
+JSON'dan çözülen değerin türü derleme anında bilinmez; `metin()` ve `sayi()` ile hangi türde kullanacağını açıkça söylersin.
+
+> **İpucu:** Bozuk olabilecek bir dosyayı çözmeden önce `json.gecerli_mi(metin)` ile denetle; geçerli değilse `yanlis` döner.
+
+## Alıştırma
+
+```alistirma
+`notlar.txt` dosyasına üç satır yaz: `Ayşe;88`, `Can;47`, `Elif;92` (ilkini `yaz`, diğerlerini `ekle` ile). Sonra dosyayı okuyup her satırı bölerek notların ortalamasını 1 basamakla `Ortalama: 75.7` biçiminde yazdır.
+%%%
+kullan kaba.sistem
+# buraya yaz
+%%%
+kullan kaba.sistem
+dosya.yaz("notlar.txt", "Ayşe;88\n")
+dosya.ekle("notlar.txt", "Can;47\n")
+dosya.ekle("notlar.txt", "Elif;92\n")
+toplam = 0
+satirlar = dosya.oku("notlar.txt").kirp().bol("\n")
+dongu satir icinde satirlar:
+    toplam += sayi(satir.bol(";")[1])
+yazdir(f"Ortalama: {toplam / satirlar.uzunluk():.1f}")
+%%%
+Ortalama: 75.7
+```

dersler/29-moduller.md

@@ -0,0 +1,169 @@
+---
+baslik: Modüller
+bolum: Hatalar ve dosyalar
+ozet: kullan ile hazır kütüphaneleri programına katmak
+---
+
+Karekök almak, bir listeyi toplamak, metnin özetini çıkarmak gibi işleri her seferinde sıfırdan yazmazsın. KabaLang'in standart kütüphanesi bu işleri **modüller** halinde hazır sunar. `kullan` ile bir modülü programına katarsın.
+
+## kullan
+
+`kullan kaba.sistem` yazınca `matematik`, `dosya`, `konsol`, `json`, `kripto`, `zaman`, `rastgele` gibi modüller birlikte gelir. Bir modülün fonksiyonu `modul.fonksiyon()` diye çağrılır.
+
+```kbl
+kullan kaba.sistem
+yazdir(matematik.karekok(144.0))
+yazdir(matematik.mutlak(-17))
+yazdir(f"{matematik.pi:.4f}")
+```
+```cikti
+12.0
+17
+3.1416
+```
+
+> **İpucu:** `kullan` satırlarını dosyanın en başına yaz. Hangi yetenekleri kullandığını okuyana hemen gösterir.
+
+## matematik
+
+| Fonksiyon | Ne yapar | Örnek | Sonuç |
+|---|---|---|---|
+| `matematik.karekok(x)` | karekök | `karekok(9.0)` | `3.0` |
+| `matematik.mutlak(x)` | mutlak değer | `mutlak(-3)` | `3` |
+| `matematik.yuvarla(x)` | en yakın tam değere yuvarla | `yuvarla(2.5)` | `3.0` |
+| `matematik.taban(x)` | aşağı yuvarla | `taban(3.7)` | `3.0` |
+| `matematik.tavan(x)` | yukarı yuvarla | `tavan(3.2)` | `4.0` |
+| `matematik.us(a, b)` | a üzeri b | `us(2.0, 10.0)` | `1024.0` |
+| `matematik.pi` | π sayısı | | `3.14159…` |
+
+```kbl
+kullan kaba.sistem
+yazdir(matematik.yuvarla(2.5))
+yazdir(matematik.taban(3.7))
+yazdir(matematik.tavan(3.2))
+yazdir(matematik.us(2.0, 10.0))
+```
+```cikti
+3.0
+3.0
+4.0
+1024.0
+```
+
+`yuvarla`, `taban` ve `tavan` sonucu `ondalik` olarak verir. Tam sayı gerekiyorsa `sayi(matematik.tavan(x))` yazarsın.
+
+Gerçek bir örnek: dairenin alanı ve bir dik üçgenin hipotenüsü.
+
+```kbl
+kullan kaba.sistem
+yaricap = 2.5
+yazdir(f"Alan: {matematik.pi * yaricap * yaricap:.2f}")
+a = 3.0
+b = 4.0
+yazdir(f"Hipotenüs: {matematik.karekok(a * a + b * b)}")
+```
+```cikti
+Alan: 19.63
+Hipotenüs: 5.0
+```
+
+## koleksiyon
+
+`kullan kaba.koleksiyon` listelerle çalışan hazır fonksiyonları getirir. Bunları *Liste işlemleri* dersinde görmüştün.
+
+```kbl
+kullan kaba.koleksiyon
+satislar = [120, 340, 90, 410, 250]
+yazdir(koleksiyon.topla(satislar))
+yazdir(koleksiyon.en_buyuk(satislar))
+yazdir(koleksiyon.sirali(satislar))
+```
+```cikti
+1210
+410
+[90, 120, 250, 340, 410]
+```
+
+## kripto
+
+`kripto` metinlerin özetini (hash) çıkarır ve base64 kodlaması yapar. Özet, bir metnin parmak izidir: metin bir harf bile değişse özet tümden değişir.
+
+```kbl
+kullan kaba.sistem
+yazdir(kripto.sha256("merhaba").bastan(16))
+yazdir(kripto.sha256("Merhaba").bastan(16))
+kod = kripto.base64_kodla("KabaLang")
+yazdir(kod)
+yazdir(kripto.base64_coz(kod))
+```
+```cikti
+4c6bcdd55f3153e1
+7fdc9f4717c5fe66
+S2FiYUxhbmc=
+KabaLang
+```
+
+## Diğer modüller
+
+| Modül | Ne için |
+|---|---|
+| `dosya` | dosya okuma/yazma (*Dosyalar* dersi) |
+| `konsol` | klavyeden okuma (*Kullanıcıdan girdi* dersi) |
+| `json` | JSON üretme ve çözme |
+| `zaman` | saat, tarih, süre ölçümü |
+| `rastgele` | rastgele sayı ve seçim |
+
+`zaman` ve `rastgele` her çalıştırmada farklı sonuç verir. Örneğin `rastgele.sayi(1, 6)` bir zar atar, `zaman.saat()` şu anki saati verir. Kendi bilgisayarında **Dene** ile çalıştırıp her seferinde değiştiğini gör:
+
+```kbl goster
+kullan kaba.sistem
+yazdir("Saat: " + zaman.saat())
+yazdir(f"Zar: {rastgele.sayi(1, 6)}")
+```
+
+> **Dikkat:** Modül adlarını değişken adı olarak kullanma. `dosya = "notlar.txt"` gibi bir atama, `dosya` modülünü gölgeleyip kafa karıştırıcı hatalara yol açar; `dosya_adi` gibi bir ad seç.
+
+## Tebrikler!
+
+Temel dersleri bitirdin: değişkenler, koşullar, döngüler, listeler, sözlükler, fonksiyonlar, kendi türlerin, hata yönetimi ve dosyalar. Artık **Örnekler** bölümündeki daha büyük programları okuyabilir, kendi küçük projelerine başlayabilirsin.
+
+## Alıştırma
+
+```alistirma
+`alanlar` listesindeki her sayı bir karenin alanı. `matematik.karekok` ile her karenin kenar uzunluğunu bulup `Alan 49.0 → kenar 7.0` biçiminde yazdır.
+%%%
+kullan kaba.sistem
+alanlar = [49.0, 2.25, 100.0]
+# buraya yaz
+%%%
+kullan kaba.sistem
+alanlar = [49.0, 2.25, 100.0]
+dongu a icinde alanlar:
+    yazdir(f"Alan {a} → kenar {matematik.karekok(a)}")
+%%%
+Alan 49.0 → kenar 7.0
+Alan 2.25 → kenar 1.5
+Alan 100.0 → kenar 10.0
+```
+
+```alistirma
+`fiyatlar` listesindeki her fiyatı `matematik.tavan` ile yukarı yuvarla, `sayi()` ile tam sayıya çevirip listeye ekle ve `koleksiyon.topla` ile yuvarlanmış fiyatların toplamını bul. Önce yuvarlanmış listeyi, sonra toplamı yazdır.
+%%%
+kullan kaba.sistem
+kullan kaba.koleksiyon
+fiyatlar = [12.3, 7.8, 19.01]
+yuvarlanmis = []
+# buraya yaz
+%%%
+kullan kaba.sistem
+kullan kaba.koleksiyon
+fiyatlar = [12.3, 7.8, 19.01]
+yuvarlanmis = []
+dongu f icinde fiyatlar:
+    yuvarlanmis.ekle(sayi(matematik.tavan(f)))
+yazdir(yuvarlanmis)
+yazdir(koleksiyon.topla(yuvarlanmis))
+%%%
+[13, 8, 20]
+41
+```

dersler/BICIM.md

@@ -0,0 +1,90 @@
+# Ders dosyası biçimi
+
+Online IDE'nin **Dersler** bölümü bu dizindeki `NN-ad.md` dosyalarından üretilir
+(dosya adı sırası = ders sırası). Her ders tek dosyadır.
+
+⚠️ Yayına almadan önce `hazirla.py` her çalıştırılabilir kod bloğunu ve her
+alıştırmanın çözümünü **gerçekten derleyip çalıştırır** ve çıktıyı dosyada
+yazanla karşılaştırır. Tutmayan ders listeye girmez.
+
+## Başlık bilgisi
+
+```
+---
+baslik: Değişkenler
+bolum: Temeller
+ozet: Değerlere ad vermek, türler ve atama
+---
+```
+
+`bolum` aynı olan dersler yan çubukta aynı başlık altında toplanır.
+
+## Metin
+
+Düz paragraf, `## Alt başlık`, `### Küçük başlık`, **kalın**, *eğik*,
+`satır içi kod`, [bağlantı](https://…), `-` ya da `1.` ile listeler,
+`| a | b |` tabloları (ikinci satır `|---|---|`).
+
+Not kutusu: `>` ile başlayan satırlar. İlk sözcük türü belirler:
+
+```
+> **İpucu:** …        (bilgi)
+> **Dikkat:** …       (uyarı)
+> **Not:** …          (nötr)
+```
+
+## Kod örneği
+
+Kod bloğu `kbl` dilinde yazılır. Hemen ardından gelen `cikti` bloğu beklenen
+çıktıdır; ikisi birlikte doğrulanır ve sayfada "Dene" düğmesiyle gösterilir.
+
+    ```kbl
+    yazdir("Merhaba")
+    ```
+    ```cikti
+    Merhaba
+    ```
+
+Program girdi okuyorsa `girdi` bloğu `cikti`dan önce gelir; satırlar sırayla
+standart girdiye verilir:
+
+    ```kbl
+    kullan kaba.sistem
+    konsol.yaz("Adın: ")
+    ad = konsol.satir_oku().deger_veya("misafir").kirp()
+    yazdir(f"Merhaba {ad}")
+    ```
+    ```girdi
+    Ayşe
+    ```
+    ```cikti
+    Adın: Ayşe
+    Merhaba Ayşe
+    ```
+
+(Program uçbirimde çalışır; verilen girdi, kullanıcı yazmış gibi ekranda da görünür.)
+
+Doğrulanmayacak blok (ör. bilerek hatalı kod, yalnız gösterim):
+`kbl goster`. Bu blokta "Dene" düğmesi yine vardır.
+
+## Alıştırma
+
+Dersin sonunda bir ya da birkaç alıştırma. Bölümler `%%%` satırıyla ayrılır:
+soru (markdown) · başlangıç kodu · çözüm · beklenen çıktı. Çözüm çalıştırılıp
+beklenen çıktıyla karşılaştırılır; öğrencinin kodu da aynı çıktıyı verince
+alıştırma tamamlanmış sayılır.
+
+    ```alistirma
+    `sayi` değişkeninin karesini ekrana yazdır.
+    %%%
+    sayi = 7
+    # buraya yaz
+    %%%
+    sayi = 7
+    yazdir(sayi * sayi)
+    %%%
+    49
+    ```
+
+Karşılaştırmada satır sonlarındaki boşluklar ve en sondaki boş satırlar yok
+sayılır.