Kerem için

Bilgisayardan Uygulamaya: Kerem için Yazılım Kitabı

İçindekiler (Syllabus)

Bu kitap bir binayı temelden çatıya anlatır. Önce bilgisayarın kendisi (temel ve taşıyıcı sistem), sonra yazılım geliştirme (inşaat), en sonda yapay zekâ (merak katı). Her bölüm bir öncekinin üstüne kurulur; hiçbir bölüm henüz anlatılmamış bir kavrama dayanmaz. Bir kavram ilk kez geçtiğinde Türkçesi yazılır, İngilizcesi parantezde verilir, çünkü dokümantasyonu İngilizce okuyacaksın.

Her bölümün başında iki satır var:

Neden burada: bu bölümün kitaptaki yeri, hangi soruyu cevapladığı.
Neye dayanıyor: okumadan önce bilmen gereken önceki bölümler.

Her bölümün sonunda geri çağırma soruları (retrieval) var: kitabı kapatıp cevaplamaya çalışırsın, sonra kontrol edersin. Takıldığın her yeri yapay zekâ öğretmenine sorabilirsin; bu kitap bir sohbetin yerine değil, sohbetin omurgası olarak yazıldı.

Örnekler mümkün olduğunca bizim uygulamamızdan: hukuk öğrenmek için Duolingo benzeri bir uygulama (bölümler, puan, seri/streak, leaderboard). Bugün vanilla HTML/CSS/JS prototip, yarın Expo + TypeScript ön yüz, Go arka uç, Postgres veritabanı, Redis önbellek.

KISIM I — MAKİNE: Elektrikten tarayıcıya

Kerem'in sorusu: "HTML'e gelene kadar neler var?" Bu kısım o merdiveni basamak basamak çıkar. Detaya değil, her katın işine ve komşu katlarla bağına odaklanır.

Ana kaynaklar: CS50x ders notları (Hafta 0–5), Nisan & Schocken, The Elements of Computing Systems (Nand2Tetris), Charles Petzold, Code, Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), Bryant & O'Hallaron, Computer Systems: A Programmer's Perspective (CS:APP), Computer Science from the Bottom Up, MDN, Ilya Grigorik, High Performance Browser Networking.

Bölüm 1. Büyük Harita: Bilgisayar nedir, katlar nasıl üst üste biner (The big picture)okunabilir

Neden burada: Her şeyden önce bir kat planı lazım. Sonraki her bölüm bu haritadaki bir kata yerleşecek; "daldan dala atlama" hissini bu harita önler.
Neye dayanıyor: Hiçbir şeye. Gündelik deneyim (telefon, laptop) ve senin bina benzetmen yeter.
1.1 Bilgisayar ne yapar: girdi (input) → işlem (processing) → çıktı (output), artı saklama (storage); kara kutu (black box) fikri
1.2 Adım adım tarif: algoritma (algorithm), program (program), komut (instruction); telefon rehberinde isim arama; sözde kod (pseudocode)
1.3 Programlamanın dört yapı taşı: fonksiyon (function), koşul (conditional), Boole ifadesi (Boolean expression), döngü (loop); bir de değişken (variable)
1.4 Soyutlama (abstraction): alt katı bilmeden üst katı kullanmak; arayüz (interface) ve gerçekleme (implementation); kanun metni ile uygulaması benzetmesi
1.5 Kat planı: elektrik → transistör → mantık kapısı → devreler (toplayıcı, bellek) → işlemci (CPU) → makine dili → assembly → C gibi diller → işletim sistemi → uygulamalar (tarayıcı) → ağ → HTML/CSS/JS → bizim uygulamamız
1.6 Donanım (hardware), yazılım (software) ve ikisinin arasındaki gömülü yazılım (firmware)
1.7 Önizleme: Kerem'in index.html dosyası açıldığında her katta ne olur (tek paragraf, her katın adıyla)
1.8 Bu kitap nasıl okunur: sıra, "neye dayanıyor" satırları, sözlük (glossary), bölüm sonu soruları

Bölüm 2. Bit ve Byte: Her şey sayıdır (Bits, bytes and representation)okunabilir

Neden burada: Haritanın en alt katında elektrik var ve elektrik yalnızca "var / yok" taşır. Bu bölüm o ikiliğin nasıl harfe, renge, sese dönüştüğünü gösterir.
Neye dayanıyor: Bölüm 1 (girdi-çıktı, soyutlama, kat planı).
2.1 Sayı sistemleri: birli (unary), onluk (decimal, base-10), ikilik (binary, base-2); basamak değeri (place value)
2.2 Bit (binary digit): açık/kapalı, 1/0; ampul ve transistör benzetmesi; n bit ile 2ⁿ farklı durum
2.3 Byte (8 bit), 0–255 aralığı; kilobyte, megabyte, gigabyte (KB, MB, GB); 1000 mü 1024 mü (KB ve KiB)
2.4 Onaltılık sayılar (hexadecimal, base-16): 0–9 ve A–F; CSS'teki #FF0000 neden böyle yazılır
2.5 Harfleri sayıya çevirmek, kodlama (encoding): ASCII (128 karakter), Unicode ve kod noktası (code point, U+0041), UTF-8 (değişken uzunluk, 1–4 byte); ş, ğ, İ ve emoji; HTML'deki <meta charset="utf-8"> satırı neden var
2.6 Renk ve görüntü: RGB, piksel (pixel), çözünürlük (resolution); CSS'teki rgb() ve hex renkler
2.7 Ses ve video: örnekleme (sampling), kare (frame); sıkıştırma (compression) fikri
2.8 Anlam bağlamdadır: aynı 72-73-33 hem "HI!" hem açık sarı; dosya biçimi (file format), uzantı (extension), veri tipi (data type) fikrine ilk adım

Bölüm 3. Elektrikten Mantığa: Transistör ve mantık kapıları (Transistors and logic gates)

Neden burada: Bit'i tanıdık; şimdi bitlerle "karar veren" en küçük parçayı görüyoruz. Bilgisayarın tüm zekâsı bu küçük kararların birleşimidir.
Neye dayanıyor: Bölüm 2 (bit, 0/1).
3.1 Elektrik akımı ve gerilim (voltage) çok kısaca; 0 ve 1 = düşük ve yüksek gerilim
3.2 Transistör (transistor): elektrikle açılıp kapanan anahtar (switch); yarı iletken (semiconductor), silikon (silicon), çip (chip), entegre devre (integrated circuit); Moore yasası (Moore's law)
3.3 Boole mantığı (Boolean logic): doğru/yanlış (true/false); VE (AND), VEYA (OR), DEĞİL (NOT); doğruluk tablosu (truth table); hukuktaki kümülatif şartlar (VE) ve seçimlik şartlar (VEYA)
3.4 NAND ve evrensellik (universality): bütün kapılar tek bir kapıdan kurulabilir; XOR
3.5 Köprü: JavaScript'teki &&, ||, ! ve if aynı mantığın üst kattaki hali

Bölüm 4. Kapılardan Hesaba: Toplayıcı ve ALU (Arithmetic: adders and the ALU)

Neden burada: Kapılar tek tek karar verir; uygun biçimde bağlanınca toplama yapan bir makine çıkar. Hesap, mantığın birleşiminden doğar.
Neye dayanıyor: Bölüm 3 (kapılar), Bölüm 2 (ikilik sayılar).
4.1 İkilik toplama ve elde (carry)
4.2 Yarım toplayıcı (half adder), tam toplayıcı (full adder), çok bitlik toplayıcı
4.3 Negatif sayılar: ikiye tümleyen (two's complement); taşma (overflow) ve gerçek hayattan taşma hataları
4.4 Ondalıklı sayılar: kayan nokta (floating point); JavaScript'te 0.1 + 0.2 neden 0.30000000000000004
4.5 ALU (Arithmetic Logic Unit): hangi işlemin yapılacağını seçen devre; kombinasyonel devre (combinational logic)

Bölüm 5. Hafıza: Bir devre nasıl hatırlar (Memory: flip-flops, registers, RAM)

Neden burada: Toplayıcı unutkandır: girdiyi çekince sonuç kaybolur. Zamanı ve hafızayı ekleyince "durum" doğar; programın bir şeyi hatırlaması buradan gelir.
Neye dayanıyor: Bölüm 3–4.
5.1 Ardışık devre (sequential logic) ve geri besleme (feedback)
5.2 Mandal (latch), flip-flop; saat sinyali (clock), saat hızı (clock speed, GHz)
5.3 Yazmaç (register): birkaç byte'lık, en hızlı hafıza
5.4 RAM (Random Access Memory): adres (address), hücre; okuma/yazma; uçucu bellek (volatile memory)
5.5 Durum (state): uygulamamızdaki puan ve seri (streak) değişkeninin fiziksel karşılığı

Bölüm 6. İşlemci: Komutları çalıştıran makine (The CPU)

Neden burada: ALU + yazmaçlar + RAM + bir yönetici = programlanabilir bilgisayar. Önceki üç bölümün parçaları burada tek makinede birleşir.
Neye dayanıyor: Bölüm 4–5.
6.1 Program da veridir: depolanmış program (stored-program) fikri, von Neumann mimarisi (von Neumann architecture)
6.2 Getir – çöz – çalıştır döngüsü (fetch–decode–execute cycle), program sayacı (program counter)
6.3 Kontrol birimi (control unit), veri yolu (bus)
6.4 Komut seti mimarisi (ISA, instruction set architecture): x86-64 (Intel/AMD), ARM (Apple M serisi, telefonlar), RISC-V; RISC ve CISC farkı
6.5 Çok çekirdek (multi-core) ve paralellik ilk bakış; GPU ne farklı yapar (Kısım III'e not)
6.6 Aynı program neden Mac'te ve Windows PC'de ayrı derlenir (ikili uyumluluk, binary compatibility); Rosetta 2

Bölüm 7. Makine Dili ve Assembly (Machine code and assembly)

Neden burada: İşlemcinin anladığı dili görmeden, insan dilinden makine diline çeviren "derleyici"yi anlayamayız.
Neye dayanıyor: Bölüm 6.
7.1 Makine kodu (machine code): komutlar da bit dizisidir; işlem kodu (opcode), işlenen (operand)
7.2 Assembly: makine kodunun insanca okunur hali; assembler
7.3 Temel komut türleri: yükle/sakla (load/store), aritmetik, atlama (jump), dallanma (branch); if ve döngünün en alttaki hali
7.4 Küçük örnek: iki sayıyı toplayan program (Nand2Tetris Hack makinesi)
7.5 Bugün neden neredeyse kimse assembly yazmıyor ve nerede hâlâ yaşıyor

Bölüm 8. Bellek Hiyerarşisi: Hız ile kapasitenin pazarlığı (Memory hierarchy)

Neden burada: İşlemci çok hızlı, RAM görece yavaş, disk daha da yavaş. Bu boşluk bütün yazılım mimarisini şekillendirir; ileride Redis'i bu bölüm açıklayacak.
Neye dayanıyor: Bölüm 5–6.
8.1 Yazmaç → L1/L2/L3 önbellek → RAM → SSD/HDD → ağ; gecikme (latency) rakamları ve insan ölçeğine çevrilmiş halleri
8.2 Önbellek (cache) fikri: sık kullanılanı yakına koy; isabet/ıska (hit/miss); yerellik (locality)
8.3 Kalıcı depolama (persistent storage): SSD, HDD, flash; uçucu ve kalıcı farkı
8.4 Aynı fikir üst katlarda tekrar eder: tarayıcı önbelleği, CDN, Redis (Bölüm 40'a köprü)

Bölüm 9. İlk Gerçek Dil: C ve derleyici (C and the compiler)

Neden burada: Assembly'nin bir kat üstü. İnsanın yazdığı metnin makine koduna nasıl dönüştüğünü görürüz. CS50'nin yolunu izler.
Neye dayanıyor: Bölüm 7 (makine kodu), Bölüm 1.3 (yapı taşları).
9.1 Kaynak kod (source code), derleyici (compiler), derleme (compiling), çalıştırılabilir dosya (executable)
9.2 hello, world: #include, main, printf; sözdizimi (syntax)
9.3 Değişken (variable), tip (type: int, char, float, bool), atama (assignment)
9.4 Koşul (if/else), döngü (while, for), fonksiyon (function), parametre (parameter), dönüş değeri (return value)
9.5 Derlemenin aşamaları: ön işleme (preprocessing), derleme, assembly, bağlama (linking); kütüphane (library)
9.6 Hata türleri: sözdizimi hatası (syntax error), çalışma zamanı hatası (runtime error), mantık hatası (logic error); hata ayıklama (debugging)
9.7 Aynı kavramların JavaScript'teki karşılıkları (Kerem'in prototipinden)

Bölüm 10. C ile Belleğe Dokunmak: Dizi, adres, pointer (Arrays, addresses, pointers)

Neden burada: Bölüm 5'teki RAM adreslerini bu kez programcının gözünden görürüz. Modern dillerin neden "bellek güvenliği" ile övündüğü burada anlaşılır.
Neye dayanıyor: Bölüm 5, 9.
10.1 Dizi (array): yan yana hücreler; indeks (index) 0'dan başlar
10.2 Karakter dizisi (string) ve sonlandırıcı \0
10.3 Adres ve işaretçi (pointer): & ve *
10.4 Yığın ve öbek (stack ve heap); malloc / free; bellek sızıntısı (memory leak)
10.5 Bellek güvenliği (memory safety): arabellek taşması (buffer overflow), segmentation fault; çöp toplayıcı (garbage collector) ve sahiplik (ownership) bu sorunu nasıl çözer
10.6 Değer ve referans (value vs reference): JavaScript'te nesne kopyalarken yaşanan sürprizler

Bölüm 11. Veri Yapıları ve Algoritmalar: Düşünme araçları (Data structures and algorithms)

Neden burada: Bellekte verinin nasıl durduğunu gördük; veriyi nasıl düzenlediğin, programın ne kadar hızlı olduğunu belirler.
Neye dayanıyor: Bölüm 10, Bölüm 1.2.
11.1 Verimlilik ölçüsü: büyük O gösterimi (big-O notation): O(1), O(log n), O(n), O(n²)
11.2 Arama: doğrusal arama (linear search), ikili arama (binary search)
11.3 Sıralama: seçmeli (selection), kabarcık (bubble), birleştirmeli (merge sort)
11.4 Özyineleme (recursion)
11.5 Veri yapıları: bağlı liste (linked list), ağaç (tree), karma tablo (hash table), kuyruk ve yığın (queue, stack)
11.6 Uygulamamızda: leaderboard sıralaması, soru bankasında arama; veritabanı dizinine (index, B-tree) köprü

Bölüm 12. Açılış: Firmware, BIOS/UEFI ve önyükleme (Firmware and booting)

Neden burada: Donanım da program da hazır. Ama düğmeye basınca ilk kodu kim çalıştırır? Donanımla yazılımın el sıkıştığı an.
Neye dayanıyor: Bölüm 6–8.
12.1 Gömülü yazılım (firmware): donanıma yerleşik program; ROM ve flash
12.2 BIOS ve UEFI; açılış testi (POST, power-on self-test)
12.3 Önyükleyici (bootloader): çekirdeği belleğe yüklemek
12.4 Apple silicon Mac ve telefonlarda açılış; güvenli önyükleme (secure boot)

Bölüm 13. İşletim Sistemi: Donanımın idaresi (What an operating system is)

Neden burada: Önyükleyici işletim sistemini başlatır. Artık bütün programların ortak bir "idaresi" var: kaynak dağıtır, kural koyar, izin verir.
Neye dayanıyor: Bölüm 12.
13.1 İşletim sisteminin (OS) üç büyük işi: sanallaştırma (virtualization), eşzamanlılık (concurrency), kalıcılık (persistence)
13.2 Çekirdek (kernel) ve kullanıcı alanı (user space); ayrıcalık seviyeleri (privilege levels, kernel mode)
13.3 Sistem çağrısı (system call): programın işletim sisteminden hizmet istemesi; API kavramına ilk temas
13.4 Kaynak yönetimi ve yalıtım (isolation); idare hukuku benzetmesi: yetki, izin, sınır

Bölüm 14. Süreçler ve İş Parçacıkları (Processes, threads, scheduling)

Neden burada: İşletim sisteminin ilk büyük işi: tek işlemciyi onlarca programa paylaştırmak.
Neye dayanıyor: Bölüm 13, 6.
14.1 Program ile süreç (process) farkı; süreç kimliği (PID); Etkinlik Monitörü / Görev Yöneticisi
14.2 Bağlam değişimi (context switch), zamanlayıcı (scheduler), zaman dilimi (time slice)
14.3 İş parçacığı (thread); eşzamanlılık (concurrency) ile paralellik (parallelism) farkı
14.4 Yarış durumu (race condition) ve kilit (lock); veritabanı işlemine (transaction) köprü
14.5 Önizleme: JavaScript'in tek iş parçacığı ve olay döngüsü (event loop); Go'nun goroutine'leri

Bölüm 15. Sanal Bellek (Virtual memory)

Neden burada: İşletim sistemi işlemciyi paylaştırdığı gibi belleği de paylaştırır; her programa kendi özel alanını verir.
Neye dayanıyor: Bölüm 10, 14.
15.1 Adres alanı (address space): her süreç belleğin tamamı kendisininmiş gibi yaşar
15.2 Sayfalama (paging), sayfa tablosu (page table), bellek yönetim birimi (MMU)
15.3 Takas (swap), bellek baskısı (memory pressure); yalıtım ve güvenlik
15.4 Tarayıcı sekmeleri neden ayrı süreçlerde çalışır

Bölüm 16. Dosyalar ve Dosya Sistemleri (Files and file systems)

Neden burada: İşletim sisteminin üçüncü işi, kalıcılık. Elektrik kesilince geriye ne kalır?
Neye dayanıyor: Bölüm 8.3, 13.
16.1 Dosya (file), dizin/klasör (directory), yol (path): mutlak ve göreli (absolute, relative); HTML'deki <link href="style.css"> göreli bir yoldur
16.2 Dosya sistemi (file system): APFS, ext4, NTFS
16.3 Dosya izinleri (permissions) ve sahiplik (ownership)
16.4 Metin dosyası ve ikili dosya (text vs binary); uzantılar
16.5 Veritabanı neden "sadece bir dosya" değildir (Bölüm 38'e köprü)

Bölüm 17. Donanımla Konuşmak: Sürücüler ve giriş/çıkış (Device drivers and I/O)

Neden burada: İşletim sistemi klavyeyi, ekranı, ağ kartını nasıl tanır? Donanım ile yazılımın kalıcı arayüzü.
Neye dayanıyor: Bölüm 13.
17.1 Giriş/çıkış aygıtları (I/O devices): klavye, ekran, disk, ağ kartı
17.2 Sürücü (driver): işletim sistemi ile donanım arasındaki tercüman
17.3 Kesme (interrupt), yoklama (polling), doğrudan bellek erişimi (DMA)
17.4 Donanım–yazılım ilişkisinin tam tablosu: Bölüm 1'deki kat planına dönüş

Bölüm 18. İşletim Sistemleri Ailesi ve Terminal (macOS, Linux, Windows and the shell)

Neden burada: Teoriyi gördük; şimdi her gün kullandığımız somut sistemler ve onlarla yazıyla konuşma aracı. Geliştirici olarak en çok burada yaşayacaksın.
Neye dayanıyor: Bölüm 13–17.
18.1 Soy ağacı: Unix, BSD, macOS (Darwin/XNU), iOS; Linux (çekirdek + dağıtım: Ubuntu), Android; Windows (NT) ayrı kol
18.2 POSIX: Unix ailesinin ortak dili
18.3 Terminal, kabuk (shell: zsh, bash), komut satırı (CLI) ile grafik arayüz (GUI) farkı
18.4 Temel komutlar: pwd, ls, cd, mkdir, cat; ortam değişkeni (environment variable), PATH
18.5 Paket yöneticisi (package manager): Homebrew, apt
18.6 Sunucular neden çoğunlukla Linux; Mac neden geliştirici dostu

Bölüm 19. Ağ: Bilgisayarlar nasıl konuşur (Networking fundamentals)

Neden burada: Tek makinenin hikâyesi bitti; şimdi makineler arası. Ağ kartı (17) bitleri (2) kabloya ve havaya nasıl çıkarır?
Neye dayanıyor: Bölüm 2, 17.
19.1 Ağ (network): LAN, WAN, Wi-Fi, Ethernet; modem, yönlendirici (router), anahtar (switch)
19.2 Paket (packet): veriyi parçalara bölmek; paket anahtarlama (packet switching)
19.3 Protokol (protocol): üzerinde anlaşılmış kurallar; katmanlı model (TCP/IP modeli, OSI'ye kısa not)
19.4 IP adresi (IPv4, IPv6), yönlendirme (routing), internet servis sağlayıcı (ISP)
19.5 TCP ve UDP: güvenilir teslim, el sıkışma (handshake), port
19.6 İstemci–sunucu modeli (client–server model): ilk tanım

Bölüm 20. İnternet ve Web: HTML'e varış (The internet, the web and the browser)

Neden burada: Merdivenin son basamağı. "HTML'e gelene kadar neler var" sorusu burada kapanır ve Kısım II'nin kapısı açılır.
Neye dayanıyor: Bölüm 1–19'un hepsi.
20.1 İnternet ve web aynı şey değil; web'in doğuşu (Tim Berners-Lee, CERN)
20.2 URL'nin anatomisi: şema (scheme), alan adı (domain), yol (path), sorgu (query)
20.3 DNS: alan adını IP adresine çevirmek
20.4 HTTP ve HTTPS; TLS ile şifreleme; istek ve yanıt (request, response)
20.5 Tarayıcı (browser) da bir programdır: işleme motoru (rendering engine), JavaScript motoru (V8)
20.6 "Adres çubuğuna yazıp Enter'a bastığında ne olur": Kısım I'in tek akışta özeti
20.7 HTML, CSS ve JS'in tarayıcıdaki yeri; Kısım II'ye kapı

KISIM II — İNŞAAT: Yazılım geliştirme (Development)

Makineyi tanıdık. Şimdi üstüne bina dikiyoruz: önce ön yüz (frontend), sonra arka uç (backend), sonra veriyi saklama, güvenlik, yayına alma ve mimari. Her bölüm bizim hukuk uygulamamızın bir parçasını kurar.

Ana kaynaklar: MDN Learn, javascript.info, TypeScript Handbook, react.dev, Expo ve TanStack belgeleri, Pro Git, A Tour of Go / Effective Go / Go FAQ, PostgreSQL belgeleri, Redis belgeleri, OWASP, The Twelve-Factor App, Martin Fowler'ın yazıları, roadmap.sh, CS50x notları (Hafta 6–9).

Bölüm 21. Programlama Dilleri Haritası (The landscape of programming languages)

Neden burada: C'yi gördük (9), JavaScript'i kullanıyoruz. İnşaata başlamadan önce dillerin neden bu kadar çok olduğunu ve neye göre ayrıldığını bir harita olarak kuruyoruz.
Neye dayanıyor: Bölüm 7, 9, 10.
21.1 Seviye: düşük seviyeli (low-level) ve yüksek seviyeli (high-level) diller
21.2 Çalıştırma biçimi: derlenen (compiled), yorumlanan (interpreted), anında derleme (JIT); ara kod (bytecode) ve sanal makine (virtual machine, JVM)
21.3 Tip sistemleri (type systems): statik ve dinamik (static, dynamic), güçlü ve zayıf (strong, weak), tip çıkarımı (type inference)
21.4 Bellek yönetimi: elle, çöp toplayıcı (garbage collection), sahiplik (ownership)
21.5 Paradigmalar: buyurgan (imperative), yordamsal (procedural), nesne yönelimli (OOP: sınıf, nesne, kalıtım), fonksiyonel (functional), bildirimsel (declarative: HTML, SQL)
21.6 Dil kartları, her biri "nerede ve neden" ile: C (işletim sistemi, gömülü), C++ (oyun motoru, tarayıcı, performans), Python (veri, yapay zekâ, betik), JavaScript (tarayıcı, Node), TypeScript (büyük JS projeleri), Go (sunucu, bulut altyapısı), Rust (güvenli sistem yazılımı), Java ve Kotlin (Android, kurumsal), Swift (Apple), SQL (veri); kısaca C#, PHP, Ruby
21.7 Bizim yığınımız (tech stack): TypeScript + Go + SQL; neden bu üçlü

Bölüm 22. Uygulama Türleri (Kinds of applications: web, mobile, desktop)

Neden burada: Dillerin nerede çalıştığını gördük; şimdi ürün türlerini ve her birinin hangi parçalardan oluştuğunu görüyoruz.
Neye dayanıyor: Bölüm 18, 20, 21.
22.1 Web uygulaması: web sitesi ile web uygulaması farkı; tek sayfa uygulama (SPA)
22.2 Mobil: yerel (native: Swift, Kotlin), çapraz platform (cross-platform: React Native/Expo, Flutter), PWA; APK ve uygulama mağazaları
22.3 Masaüstü: yerel uygulamalar, Electron
22.4 Her türde istemci (client) ve sunucu (server) parçaları
22.5 Uygulamamızın türü: web + mobil (Expo) + Go arka uç

Bölüm 23. HTML ve DOM: Belgenin iskeleti (HTML and the DOM)

Neden burada: Tarayıcıya vardık (20). Tarayıcının ilk okuduğu şey HTML.
Neye dayanıyor: Bölüm 20, 16 (yollar), 2.5 (karakter kodlaması).
23.1 İşaretleme dili (markup language): etiket (tag), öğe (element), nitelik (attribute)
23.2 Belge yapısı: <!doctype>, head, body, meta
23.3 Anlamsal HTML (semantic HTML) ve erişilebilirlik (accessibility, a11y)
23.4 Formlar ve girdiler (form, input, button)
23.5 DOM (Document Object Model): HTML'in bellekteki ağaç hali; düğüm (node)
23.6 Kerem'in prototipinin HTML'ini birlikte okumak

Bölüm 24. CSS: Görünüm ve yerleşim (CSS: styling and layout)

Neden burada: İskelet hazır; şimdi görünüş. Yapı ile sunumun ayrılması.
Neye dayanıyor: Bölüm 23.
24.1 Kural (rule), seçici (selector), özellik (property), değer (value)
24.2 Kaskad (cascade), özgüllük (specificity), kalıtım (inheritance)
24.3 Kutu modeli (box model): margin, border, padding, content
24.4 Yerleşim (layout): flexbox, grid; konumlandırma (positioning)
24.5 Duyarlı tasarım (responsive design), medya sorgusu (media query), önce mobil (mobile-first)
24.6 CSS değişkenleri (custom properties) ve tasarım sistemi (design system) fikri

Bölüm 25. JavaScript: Bir dil olarak (JavaScript as a language)

Neden burada: Davranış katmanı. Bölüm 9'da C'de gördüğün her kavramın JavaScript karşılığını bulacaksın.
Neye dayanıyor: Bölüm 9, 21.
25.1 Değerler ve tipler (number, string, boolean, null, undefined, object); let ve const
25.2 Fonksiyonlar, ok fonksiyonu (arrow function), kapsam (scope), kapanış (closure)
25.3 Nesne (object) ve dizi (array); JSON'a ilk bakış
25.4 Kontrol akışı ve hata yakalama (try/catch)
25.5 JavaScript motoru ve Node.js: tarayıcı dışında JavaScript
25.6 Eşzamansız programlama (asynchronous): geri çağırma (callback), Promise, async/await; olay döngüsü (event loop), Bölüm 14'e bağ

Bölüm 26. JavaScript ile Sayfayı Canlandırmak (DOM manipulation and events)

Neden burada: Dil (25) ile belge (23) birleşir. Kerem'in prototipinin kalbi bu bölüm.
Neye dayanıyor: Bölüm 23–25.
26.1 DOM API: querySelector, öğe oluşturma, metni değiştirme
26.2 Olaylar (events): click, input, submit; olay dinleyici (event listener)
26.3 Durum (state) ve ekranı güncellemek: puan, seri, soru ilerleyişi
26.4 Tarayıcıda saklama: localStorage, çerez (cookie) ilk bakış
26.5 fetch ile sunucuya istek: Bölüm 35'e köprü

Bölüm 27. Modüler Kod (Modules and code organization)

Neden burada: Kerem'in prototipi zaten ayrı dosyalarda. Neden ayırırız, ayrılan parçalar nasıl birbirine bağlanır?
Neye dayanıyor: Bölüm 25–26, 1.4 (soyutlama).
27.1 Modül (module), import / export, ES modülleri (ES modules)
27.2 Sorumlulukların ayrılması (separation of concerns), tek sorumluluk (single responsibility)
27.3 Bağımlılık (dependency); bağlaşım ve uyum (coupling, cohesion)
27.4 Klasör yapısı, isimlendirme, okunabilirlik (readability)
27.5 Derin modül (deep module) fikri: sade arayüz, zengin içerik (John Ousterhout)

Bölüm 28. Git: Kodun hafızası (Version control with Git)

Neden burada: Kod dosyalara bölündü (27); şimdi o dosyaların zaman içindeki değişimini kayıt altına alıyoruz. Commit'i biliyorsun; burada bütün sistemi görüyoruz.
Neye dayanıyor: Bölüm 16 (dosyalar), 18 (terminal), 27.
28.1 Sürüm kontrolü (version control) neden var; depo (repository), çalışma dizini (working directory), hazırlık alanı (staging area)
28.2 Commit: anlık görüntü (snapshot), commit mesajı, geçmiş (history); küçük ve tek amaçlı commit'ler
28.3 Dal (branch), birleştirme (merge), çakışma (conflict), yeniden temellendirme (rebase)
28.4 Uzak depo (remote): GitHub, push / pull / clone; çatal (fork)
28.5 Çekme isteği (pull request) ve kod incelemesi (code review)
28.6 Çalışma ağacı (git worktree): aynı depoda birden çok dal üzerinde aynı anda çalışmak (agent'larla iş için temel)
28.7 .gitignore, sırlar (secrets) neden depoya girmez

Bölüm 29. Araçlar: Node, npm ve derleme zinciri (Tooling: Node, npm, bundlers)

Neden burada: Modüller çoğalınca başkalarının kodunu da kullanırız; bunu yöneten araçlar.
Neye dayanıyor: Bölüm 25.5, 27, 28, 18.5.
29.1 Paket (package), npm, package.json, node_modules; sürümleme (semver), kilit dosyası (lock file)
29.2 Betikler (scripts) ve geliştirme sunucusu (dev server)
29.3 Paketleyici (bundler: Vite) ve dönüştürücü (transpiler)
29.4 Denetleyici ve biçimlendirici (linter, formatter: ESLint, Prettier)
29.5 Tedarik zinciri riski (supply chain risk)

Bölüm 30. TypeScript: Tiplerin güvencesi (TypeScript)

Neden burada: 21.3'teki tip fikrini JavaScript'e uygular. Expo ve TanStack ile yazacağımız dil budur.
Neye dayanıyor: Bölüm 21, 25, 29.
30.1 Neden: hatayı programı çalıştırmadan yakalamak; tip bir sözleşmedir
30.2 Temel tipler, arayüz (interface), tip takma adı (type alias), birleşim tipi (union type)
30.3 Tip denetimi ve derleme (tsc); tiplerin çalışma anında silinmesi (type erasure)
30.4 Genel tipler (generics) ilk bakış
30.5 JavaScript prototipinden TypeScript'e kademeli geçiş

Bölüm 31. Framework'ler, React ve Bileşenler (Frameworks, React, components)

Neden burada: DOM'u elle yönetmek (26) uygulama büyüdükçe zorlaşır. Framework'ler bu yükü alır.
Neye dayanıyor: Bölüm 26–30.
31.1 Kütüphane (library) ile çerçeve (framework) farkı; kontrolün tersine çevrilmesi (inversion of control)
31.2 Bileşen (component), özellikler (props), durum (state); bildirimsel arayüz (declarative UI)
31.3 JSX; yeniden çizim (re-render)
31.4 Kancalar (hooks): useState, useEffect
31.5 Yönlendirme (routing) ve sayfalar

Bölüm 32. Mobil: React Native ve Expo (React Native and Expo)

Neden burada: React'i öğrendik (31); aynı fikir telefonda. Uygulamamızın mobil hali buradan çıkacak.
Neye dayanıyor: Bölüm 22.2, 31.
32.1 React Native: JavaScript ile yerel (native) bileşenler
32.2 Expo: araç zinciri, Expo Go, EAS Build; APK/AAB ve web çıktısı
32.3 Dosya tabanlı yönlendirme (Expo Router)
32.4 Yerel modüller, izinler (permissions), anlık bildirimler (push notifications): Duolingo tarzı hatırlatma

Bölüm 33. Sunucu Verisini Yönetmek: TanStack (Server state with TanStack)

Neden burada: Arayüz sunucudan veri çekmeye başlayınca yeni sorunlar çıkar: yükleniyor durumu, hata, eski veri, önbellek.
Neye dayanıyor: Bölüm 26.5, 31, 8.2 (önbellek fikri).
33.1 İstemci durumu ile sunucu durumu (client state vs server state)
33.2 TanStack Query: sorgu (query), değişiklik (mutation), önbellek, yeniden doğrulama (revalidation)
33.3 TanStack Router ve Start kısa bakış

Bölüm 34. Arka Uç Nedir: Sunucu ve API (What a backend is: servers and APIs)

Neden burada: Ön yüz kuruldu. Leaderboard'u herkes aynı görecekse veri tek bir merkezde durmalı: sunucu.
Neye dayanıyor: Bölüm 19.6, 14 (süreçler), 22.4.
34.1 Sunucu (server): sürekli çalışan ve istek bekleyen bir süreç
34.2 Ön yüz ve arka uç (frontend, backend) iş bölümü; neden puan hesabı sunucuda yapılır (güven sınırı, trust boundary)
34.3 API (Application Programming Interface): iki program arasındaki sözleşme
34.4 Durumsuz ve durumlu (stateless, stateful) sunucu
34.5 Uygulamamızın arka ucunun görevleri: kullanıcı, ilerleme, puan, leaderboard, içerik

Bölüm 35. HTTP, JSON ve REST (HTTP, JSON and REST in depth)

Neden burada: API'yi tanıdık; web'de API'ler bu üç standartla konuşur.
Neye dayanıyor: Bölüm 20.4, 25.3, 34.
35.1 HTTP isteği: yöntem (method: GET, POST, PUT, PATCH, DELETE), başlık (header), gövde (body)
35.2 HTTP yanıtı: durum kodları (status codes: 200, 201, 400, 401, 403, 404, 500)
35.3 JSON: veri biçimi; serileştirme (serialization)
35.4 REST: kaynak (resource), uç nokta (endpoint), URL tasarımı; idempotent işlemler
35.5 Alternatifler: GraphQL, RPC kısaca
35.6 CORS, çerezler ve oturum ilk bakış

Bölüm 36. Go: Neden Go (The Go language and why we chose it)

Neden burada: Arka ucu hangi dille yazacağız? 21'deki haritadan Go'yu seçmenin gerekçeleri.
Neye dayanıyor: Bölüm 21, 9 (C), 14 (eşzamanlılık).
36.1 Go'nun doğuşu (Google, 2009) ve tasarım hedefleri: sadelik, hızlı derleme, eşzamanlılık
36.2 Temel sözdizimi: paket (package), fonksiyon, değişken, struct, metot, arayüz (interface)
36.3 Hata yönetimi: hatalar değerdir (if err != nil)
36.4 Goroutine ve kanal (channel)
36.5 Tek ikili dosya (single binary), standart kütüphane, go mod
36.6 Go ile Node, Python, Java karşılaştırması: hangi durumda hangisi

Bölüm 37. Go ile API Yazmak (Building an HTTP API in Go)

Neden burada: Dil (36) ile protokol (35) birleşir: ilk sunucumuz.
Neye dayanıyor: Bölüm 35–36.
37.1 net/http, işleyici (handler), yönlendirici (router)
37.2 JSON okumak ve yazmak; doğrulama (validation)
37.3 Ara katman (middleware): kayıt (logging), kimlik kontrolü
37.4 context, zaman aşımı (timeout)
37.5 Katmanlı yapı: handler → servis (service) → depo (repository)
37.6 Örnek: GET /leaderboard ve POST /answers uç noktaları

Bölüm 38. Veritabanları ve SQL (Databases and SQL)

Neden burada: Sunucu kapanınca veri kaybolmamalı. Dosyadan (16) neden ileri gideriz?
Neye dayanıyor: Bölüm 16, 11 (veri yapıları), 21.5 (bildirimsel).
38.1 Veritabanı (database) ve veritabanı yönetim sistemi (DBMS)
38.2 İlişkisel model (relational model): tablo (table), satır (row), sütun (column), birincil anahtar (primary key), yabancı anahtar (foreign key)
38.3 SQL: SELECT, INSERT, UPDATE, DELETE, WHERE, JOIN, GROUP BY
38.4 Normalizasyon ve şema tasarımı (schema design): kullanıcılar, bölümler, sorular, cevaplar
38.5 İlişkisel olmayan (NoSQL) veritabanları kısaca; ne zaman hangisi

Bölüm 39. Postgres Pratikte (PostgreSQL in practice)

Neden burada: Kavramlar (38) gerçek bir sistemde.
Neye dayanıyor: Bölüm 37, 38, 14.4.
39.1 Postgres neden: güvenilirlik, standartlara uyum, zengin tipler (JSONB)
39.2 Dizin (index) ve B-tree; sorgu planı (EXPLAIN)
39.3 İşlem (transaction) ve ACID; eşzamanlı yazma
39.4 Şema göçü (migration)
39.5 Go'dan bağlanmak: bağlantı havuzu (connection pool), SQL enjeksiyonu (SQL injection) ve parametreli sorgu
39.6 Yedekleme (backup)

Bölüm 40. Önbellek ve Redis (Caching and Redis)

Neden burada: Bölüm 8'deki önbellek fikri arka uç ölçeğinde. Leaderboard'u her istekte yeniden hesaplamamak.
Neye dayanıyor: Bölüm 8.2, 39.
40.1 Bellek içi veri deposu (in-memory data store); anahtar–değer (key–value)
40.2 Redis veri yapıları: string, hash, list, set, sıralı küme (sorted set): leaderboard için biçilmiş kaftan
40.3 Önbellek stratejileri: cache-aside, yaşam süresi (TTL), geçersiz kılma (invalidation)
40.4 Oturum saklama, hız sınırlama (rate limiting), kuyruk (queue)
40.5 Ne zaman önbellek gerekmez

Bölüm 41. Kimlik Doğrulama ve Güvenlik (Authentication and security)

Neden burada: Artık kullanıcılarımız ve verimiz var; kimin kim olduğunu bilmek ve veriyi korumak zorundayız.
Neye dayanıyor: Bölüm 20.4 (HTTPS), 35, 37, 39.
41.1 Kimlik doğrulama (authentication) ile yetkilendirme (authorization) farkı
41.2 Parolaları saklamak: özet fonksiyonu (hashing), tuz (salt), bcrypt/argon2
41.3 Oturum (session), çerez (cookie), belirteç (token, JWT); OAuth ile "Google ile giriş"
41.4 Yaygın saldırılar: SQL enjeksiyonu, XSS, CSRF; OWASP Top 10
41.5 Sırların yönetimi (secrets management), en az yetki ilkesi (least privilege)
41.6 Kişisel veri ve KVKK/GDPR'ye kısa bakış

Bölüm 42. Test ve Kalite (Testing and code quality)

Neden burada: Uygulama büyüdü; bir şeyi değiştirince başka bir şeyin bozulmadığından nasıl emin oluruz?
Neye dayanıyor: Bölüm 27, 30, 37.
42.1 Birim, entegrasyon ve uçtan uca testler (unit, integration, end-to-end)
42.2 Test önce geliştirme (TDD) fikri
42.3 Go'da go test, JavaScript'te test araçları
42.4 Kod incelemesi (code review) ve sürekli entegrasyon (CI) ile bağ

Bölüm 43. Yayına Alma: Sunucu, konteyner, bulut (Deployment, containers, cloud)

Neden burada: Kod Kerem'in bilgisayarında çalışıyor; herkesin erişebilmesi için başka bir bilgisayarda sürekli çalışmalı.
Neye dayanıyor: Bölüm 18, 19, 34, 42.
43.1 Ortamlar (environments): geliştirme, test, üretim (development, staging, production)
43.2 Sunucu, sanal makine (virtual machine), konteyner (container, Docker)
43.3 Bulut (cloud): IaaS, PaaS, sunucusuz (serverless); AWS, Google Cloud, Cloudflare
43.4 CI/CD: sürekli entegrasyon ve dağıtım; GitHub Actions
43.5 Alan adı, DNS kaydı, HTTPS sertifikası (Bölüm 20'ye dönüş)
43.6 Gözlem (observability): kayıt (log), ölçüm (metric), alarm
43.7 Twelve-Factor App ilkeleri; yapılandırma ortam değişkenlerinde

Bölüm 44. Mimariler (Software architecture: monolith, microservices, layers)

Neden burada: Parçaların hepsini tanıdık; şimdi bunların nasıl bir bütün oluşturduğuna dair büyük kararlar.
Neye dayanıyor: Bölüm 27, 34–43.
44.1 Mimari nedir: değiştirmesi pahalı kararlar
44.2 Monolit (monolith) ve modüler monolit
44.3 Mikroservisler (microservices): faydası, bedeli, ne zaman
44.4 Katmanlı mimari (layered architecture); sunum, iş mantığı, veri katmanları
44.5 Olay güdümlü mimari (event-driven), kuyruklar kısaca
44.6 Ölçeklenme (scaling): dikey ve yatay (vertical, horizontal), yük dengeleyici (load balancer)

Bölüm 45. Uçtan Uca: Uygulamamızın tam haritası (Our app, end to end)

Neden burada: Kısım II'nin özeti. Tek bir kullanıcı eylemini kat kat izleyerek bütün parçaları birbirine bağlarız.
Neye dayanıyor: Bölüm 21–44.
45.1 Bir cevabın yolculuğu: butona dokunma → React Native → fetch → HTTPS → Go handler → Postgres işlemi → Redis leaderboard güncellemesi → JSON yanıt → ekranda puan
45.2 Mimari çizim: hangi parça nerede çalışır
45.3 Bölüm tasarımı, oyunlaştırma (gamification) ve verinin şekli
45.4 Neyi bilmeden sürüklenmezsin: her parça için "takılırsam ne öğrenmeliyim" listesi

Bölüm 46. Yapay Zekâ Agent'larıyla Geliştirme (Developing with AI agents)

Neden burada: Kodu tek başına değil, agent'larla yazacağız. Haritayı bildiğin için agent'ı yönetebilirsin; bilmeseydin o seni sürüklerdi.
Neye dayanıyor: Bölüm 28 (git, worktree), 42, 45.
46.1 Kodlama agent'ı nedir: LLM + araçlar (dosya okuma, terminal); ayrıntısı Kısım III'te
46.2 AGENTS.md: agent'a projenin kurallarını anlatan dosya; docs/ klasörü
46.3 İyi görev tarifi: kapsam, kabul ölçütleri (acceptance criteria), küçük adımlar
46.4 git worktree ile paralel çalışan agent'lar
46.5 Agent'ın kodunu okumak ve incelemek: diff, test, küçük commit
46.6 Agent'ın sınırları: uydurma (hallucination), bağlam sınırı, güvenlik

KISIM III — MERAK: Sinir ağları ve büyük dil modelleri (Neural networks and LLMs)

Son kat. Birlikte çalıştığın yapay zekânın içinde ne var? Andrej Karpathy'nin micrograd ve makemore anlatımları metne çevrilerek izlenir: önce sezgi, sonra minik bir motor, sonra isim üreten bir dil modeli, en sonda LLM'ler.

Ana kaynaklar: Karpathy, micrograd ve makemore depoları (README ve kod), "Neural Networks: Zero to Hero" ders transkriptleri ve notları, Karpathy, "Hacker's guide to Neural Networks", 3Blue1Brown'un yazılı ders sayfaları, Jay Alammar, "The Illustrated Transformer", Vaswani vd., "Attention Is All You Need".

Bölüm 47. Yapay Zekâ Haritası (AI, machine learning, neural networks)

Neden burada: Kısım III'ün kat planı. Kural yazmak ile örnekten öğrenmek arasındaki fark.
Neye dayanıyor: Bölüm 1 (girdi → işlem → çıktı), Bölüm 21.
47.1 Yapay zekâ (AI), makine öğrenmesi (machine learning), derin öğrenme (deep learning): iç içe kümeler
47.2 Kural tabanlı program ile öğrenen program: kuralı yazmak yerine örnekten çıkarmak
47.3 Model (model), parametre (parameter), eğitim (training), çıkarım (inference)
47.4 Denetimli öğrenme (supervised learning): girdi–etiket çiftleri
47.5 Kısım III'ün yol haritası

Bölüm 48. Matematik Sezgisi: Eğim ve türev (Slopes and derivatives, intuitively)

Neden burada: Öğrenmek, bir düğmeyi hangi yöne çevireceğini bilmektir. Bunu bize türev söyler. Formül ezberi yok; sezgi var.
Neye dayanıyor: Bölüm 47; lise düzeyi fonksiyon fikri.
48.1 Fonksiyon (function) matematikte: girdiden çıktıya kural
48.2 Eğim (slope) ve türev (derivative): girdiyi azıcık değiştirince çıktı ne kadar değişir
48.3 Birden çok girdi: kısmi türev (partial derivative), gradyan (gradient)
48.4 Zincir kuralı (chain rule): iç içe fonksiyonlarda değişimin aktarılması

Bölüm 49. micrograd 1: Değerler ve hesap grafiği (Values and the computational graph)

Neden burada: Karpathy'nin en küçük öğrenen motoru. Her sayının nereden geldiğini kaydetmek.
Neye dayanıyor: Bölüm 48, 25 (nesneler), 11 (ağaç yapısı).
49.1 Value nesnesi: bir sayı ve onu üreten işlem
49.2 Hesap grafiği (computational graph): işlemlerin ağacı
49.3 İleri geçiş (forward pass)
49.4 Otomatik türev (autograd) nedir

Bölüm 50. micrograd 2: Geri yayılım (Backpropagation)

Neden burada: Grafiği kurduk; şimdi sonuçtan geriye doğru "kim ne kadar sorumlu" sorusunu cevaplıyoruz.
Neye dayanıyor: Bölüm 48.4, 49.
50.1 Gradyanı sondan başa taşımak
50.2 Toplama ve çarpma düğümlerinde gradyan
50.3 Topolojik sıralama (topological sort)
50.4 Elle hesaplanan bir örnek

Bölüm 51. Nöron, katman, çok katmanlı ağ (Neurons, layers, MLP)

Neden burada: Motor hazır; şimdi onunla bir beyin taklidi kuruyoruz.
Neye dayanıyor: Bölüm 49–50.
51.1 Yapay nöron (neuron): ağırlık (weight), sapma (bias), toplam
51.2 Etkinleştirme fonksiyonu (activation function): tanh, ReLU; neden doğrusal olmamak gerekir
51.3 Katman (layer) ve çok katmanlı algılayıcı (MLP, multi-layer perceptron)
51.4 Parametre sayısı ve model büyüklüğü

Bölüm 52. Eğitim: Kayıp ve gradyan inişi (Training: loss and gradient descent)

Neden burada: Ağ var, gradyan var; şimdi ikisini birleştirip öğrenme döngüsünü kuruyoruz.
Neye dayanıyor: Bölüm 50–51.
52.1 Kayıp fonksiyonu (loss function): ne kadar yanlışız
52.2 Gradyan inişi (gradient descent), öğrenme oranı (learning rate)
52.3 Eğitim döngüsü (training loop): ileri, kayıp, geri, güncelle
52.4 Sık hatalar: gradyanı sıfırlamayı unutmak; aşırı öğrenme (overfitting)
52.5 micrograd'dan PyTorch'a: aynı fikir, tensörlerle

Bölüm 53. makemore 1: Harf sayarak isim üretmek (Bigram language model by counting)

Neden burada: Öğrenmenin en basit hali: önceki harften sonraki harfi tahmin etmek. Dil modelinin doğduğu yer.
Neye dayanıyor: Bölüm 47; olasılık sezgisi.
53.1 Dil modeli (language model) nedir: sonrakini tahmin etmek
53.2 Veri kümesi (dataset): 32.000 isim; başlangıç ve bitiş işaretleri
53.3 Bigram: ardışık harf çiftlerini saymak; sayım tablosu
53.4 Sayımdan olasılığa: normalleştirme (normalization)
53.5 Örnekleme (sampling): modelden yeni isimler üretmek

Bölüm 54. Modeli Ölçmek: Olabilirlik ve kayıp (Likelihood and negative log-likelihood)

Neden burada: Ürettiğimiz isimler iyi mi? "İyi"yi sayıya çevirmek, eğitimin önkoşulu.
Neye dayanıyor: Bölüm 52.1, 53.
54.1 Olabilirlik (likelihood) ve logaritma neden
54.2 Negatif log olabilirlik (negative log-likelihood) kayıp olarak
54.3 Yumuşatma (smoothing): hiç görülmemiş çiftler

Bölüm 55. Bigram'ı Sinir Ağıyla Kurmak (The neural-network bigram)

Neden burada: Aynı problemi sayarak değil öğrenerek çözüyoruz; sonucun aynı çıkması iki yolu birbirine bağlar.
Neye dayanıyor: Bölüm 51–54.
55.1 Tek-sıcak kodlama (one-hot encoding)
55.2 Logit, softmax: sayıları olasılığa çevirmek
55.3 Tensör (tensor) ve matris çarpımı (matrix multiplication)
55.4 GPU neden: aynı işlemi binlerce kez paralel yapmak (Bölüm 6.5'e dönüş)

Bölüm 56. MLP Dil Modeli ve Gömme (MLP language model and embeddings)

Neden burada: Tek harf yetmez; daha uzun bağlam ve harflerin "anlam uzayı".
Neye dayanıyor: Bölüm 55.
56.1 Bağlam penceresi (context window): son 3 harf
56.2 Gömme (embedding): her harfe bir vektör
56.3 Bengio vd. (2003) modeli
56.4 Eğitim, doğrulama, test kümeleri (train, validation, test split); hiperparametre (hyperparameter)

Bölüm 57. Dikkat ve Transformer (Attention and the Transformer)

Neden burada: Uzun metinlerde hangi kelimenin hangisine bakacağına karar veren mekanizma: bugünkü LLM'lerin kalbi.
Neye dayanıyor: Bölüm 56.
57.1 Dikkat (attention) sezgisi: her kelime diğerlerine soru sorar
57.2 Sorgu, anahtar, değer (query, key, value)
57.3 Transformer bloğu: dikkat + MLP + artık bağlantılar (residual connections)
57.4 GPT: yalnızca kod çözücü (decoder-only) model; "Attention Is All You Need" (2017)

Bölüm 58. Büyük Dil Modelleri (Large language models)

Neden burada: Minik modelden ChatGPT'ye ve Claude'a: aynı fikir, devasa ölçek.
Neye dayanıyor: Bölüm 53–57.
58.1 Simgeleştirme (tokenization) ve simge (token)
58.2 Ön eğitim (pretraining): internet ölçeğinde sonraki simgeyi tahmin
58.3 İnce ayar (fine-tuning), talimat takibi (instruction tuning), insan geri bildirimiyle pekiştirme (RLHF)
58.4 Bağlam penceresi, sıcaklık (temperature), uydurma (hallucination)
58.5 Ölçek yasaları (scaling laws), maliyet, GPU kümeleri

Bölüm 59. Kapanış: Agent'lar ve kitabın tamamı (Agents and the whole map)

Neden burada: Kitap Bölüm 1'deki kat planıyla açıldı; aynı planın tamamlanmış haliyle kapanır.
Neye dayanıyor: Kitabın tamamı, özellikle Bölüm 46 ve 58.
59.1 Agent = LLM + araçlar + döngü; araç çağırma (tool calling)
59.2 Kerem'in iş akışında agent: neyi devredersin, neyi kendin denetlersin
59.3 Tam kat planı: elektrikten LLM'e
59.4 Buradan nereye: hangi soruda hangi kaynağa gidersin