diff --git a/README.md b/README.md index 3c2d4f4..6125386 100644 --- a/README.md +++ b/README.md @@ -125,6 +125,7 @@ Bu repo iki farklı lisansla korunmaktadır: - **Kaynak kod** — [MIT](LICENSE) - **Soru ve cevap içeriği** (`src/content/`) — [CC BY-SA 4.0](src/content/LICENSE) +- **Üçüncü taraf bildirimleri** — sudheerj/reactjs-interview-questions kaynaklı React soruları için MIT bildirimi: [THIRD_PARTY_NOTICES](src/content/THIRD_PARTY_NOTICES) İçerikleri dilediğin gibi kullanabilir, değiştirebilir ve paylaşabilirsin. Sadece kaynağı (bu repoyu) belirtmen ve türettiğin işleri de aynı lisansla paylaşman yeterli. diff --git a/src/content/LICENSE b/src/content/LICENSE index 931b210..75fd267 100644 --- a/src/content/LICENSE +++ b/src/content/LICENSE @@ -12,3 +12,7 @@ Resmi lisans metni: https://creativecommons.org/licenses/by-sa/4.0/legalcode Not: Bu lisans yalnızca src/content/ altındaki soru ve içerik dosyaları için geçerlidir. Kaynak kodun geri kalanı repo kökündeki LICENSE dosyasında belirtilen MIT lisansına tabidir. + +İstisna: THIRD_PARTY_NOTICES dosyası CC BY-SA 4.0 kapsamında değildir. +sudheerj/reactjs-interview-questions kaynaklı kısımlar için o dosyadaki +MIT lisans bildirimi geçerlidir. diff --git a/src/content/THIRD_PARTY_NOTICES b/src/content/THIRD_PARTY_NOTICES new file mode 100644 index 0000000..7fb6afc --- /dev/null +++ b/src/content/THIRD_PARTY_NOTICES @@ -0,0 +1,40 @@ +Üçüncü taraf bildirimleri +========================= + +Bu dizindeki bazı içerikler aşağıdaki üçüncü taraf eserlerden türetilmiştir. +Türetilen her soru, source alanında eserin adını taşır. Eserin lisans metni +aşağıda, kaynağındaki hâliyle ve telif satırıyla birlikte yer alır. + +------------------------------------------------------------------------------ + +sudheerj/reactjs-interview-questions +https://github.com/sudheerj/reactjs-interview-questions + +Kullanıldığı yer: src/content/tr/content-react.json içinde source alanı +"soru kaynağı: sudheerj/reactjs-interview-questions (MIT)" ile biten sorular. + +Lisans metni reponun LICENSE dosyasından alınmıştır (git blob +beea88e682cf51f41e1088d7b45c15b32f55de76; dosyayı en son değiştiren commit +942666fec23a498e76470c66334e7f87fac6a531, 2024-09-18). + +MIT License + +Copyright (c) 2017-Present Sudheer Jonna + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/src/content/tr/content-docker.json b/src/content/tr/content-docker.json index 1ab6b46..6c584d8 100644 --- a/src/content/tr/content-docker.json +++ b/src/content/tr/content-docker.json @@ -9,7 +9,7 @@ "topic": "Konteyner iletişimi", "difficulty": 2, "prompt": "Aynı host üzerinde çalışan A konteynerinden B konteynerine nasıl erişirsin? Konteyner adıyla erişmek her durumda çalışır mı?", - "modelAnswer": "İki konteyneri aynı kullanıcı tanımlı ağa koyarsın; o ağda konteyner adı DNS ismi gibi çözülür.\n\n```bash\ndocker network create app-net\ndocker run -d --name b --network app-net nginx\ndocker run -it --name a --network app-net alpine sh\n# a içinden:\nwget -qO- http://b:80\n```\n\nHer durumda çalışmaz: varsayılan bridge ağında Docker'ın gömülü DNS'i ad çözümlemesi yapmaz, konteynerler birbirine yalnızca IP ile erişir. IP'ler yeniden başlatmada değişebildiği için bu kırılgan bir yapıdır.\n\nSık atlanan bir nokta: konteynerler arası erişim için portu -p ile yayınlamak gerekmez. O bayrak servisi host makineye açar; aynı ağdaki konteynerler yayınlanmamış portlara da erişebilir.", + "modelAnswer": "İki konteyner aynı kullanıcı tanımlı ağa bağlanır (ağ `docker network create` ile açılır, konteynerler `--network` ile katılır); bu ağda Docker'ın gömülü DNS'i konteyner adını çözer ve A, B'ye adıyla ulaşır. Adla erişim her durumda çalışmaz, çünkü varsayılan bridge ağında ad çözümlemesi yoktur ve konteynerler birbirine yalnızca IP ile erişir. IP'ler yeniden başlatmada değişebildiği için bu kırılgan bir düzendir. Aynı ağdaki konteynerler birbirinin bütün portlarına erişebildiği için portu -p ile yayınlamak gerekmez; o bayrak portu host'a ve dış dünyaya açar.", "keyConcepts": [ { "id": "shared-user-network", @@ -62,7 +62,7 @@ "Docker Compose kullandığında servisler birbirini nasıl buluyor?", "Konteyner içinden host makinedeki bir servise nasıl erişirsin?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — Docker Docs: Bridge network driver (Differences between user-defined bridges and the default bridge), Port publishing and mapping" }, { "id": "docker-image-vs-container", @@ -71,14 +71,14 @@ "topic": "Temeller", "difficulty": 1, "prompt": "Image ile container arasındaki fark nedir?", - "modelAnswer": "**Image**, uygulamayı çalıştırmak için gereken her şeyi (dosya sistemi, bağımlılıklar, çalıştırılacak komut) içeren **salt okunur** bir şablondur. **Container** ise o image'dan başlatılmış **çalışan bir örnektir**.\n\nBenzetmeyle: image bir sınıf, container o sınıftan oluşturulmuş bir nesne gibidir. Aynı image'dan istediğin kadar container başlatabilirsin, her biri birbirinden yalıtılmış çalışır.\n\nImage **katmanlardan** oluşur ve değişmez. Container başlatılırken bu katmanların üstüne **yazılabilir ince bir katman** eklenir; container'ın çalışırken yaptığı tüm değişiklikler oraya yazılır.\n\nSık atlanan nokta: container silindiğinde bu yazılabilir katman da silinir. Kalıcı olması gereken veri (veritabanı dosyaları gibi) container içinde değil, **volume**'da tutulmalıdır.", + "modelAnswer": "Image, uygulamayı çalıştırmak için gereken dosya sistemini, bağımlılıkları ve başlangıç komutunu içeren salt okunur bir şablondur; container ise o image'dan başlatılmış çalışan bir örnektir. Bir sınıftan birden çok nesne üretilmesi gibi aynı image'dan birbirinden yalıtılmış istenen sayıda container başlatılabilir. Image katmanlardan oluşur ve değişmez; container başlarken bu katmanların üstüne ince, yazılabilir bir katman eklenir ve çalışırken yapılan bütün değişiklikler oraya yazılır. Container silindiğinde bu yazılabilir katman da silinir, bu yüzden kalıcı olması gereken veri container içinde değil volume'da tutulur.", "keyConcepts": [ { "id": "image-sablon", "label": "Image salt okunur şablon", "aliases": [ "şablon", - "template", + "read-only template", "salt okunur bir", "salt okunurdur", "read-only'dir" @@ -135,7 +135,7 @@ "followUps": [ "Çalışan bir container'da yaptığın değişikliği yeni bir image'a nasıl dönüştürürsün ve bu neden önerilmez?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Docker overview (Images, Containers), Storage drivers (Images and layers, Container and layers)" }, { "id": "docker-vs-vm", @@ -144,7 +144,7 @@ "topic": "Temeller", "difficulty": 1, "prompt": "Docker container ile sanal makine (VM) arasındaki fark nedir?", - "modelAnswer": "**Sanal makine**, hypervisor üzerinde çalışan ve **kendi tam işletim sistemini** (kendi kernel'i dahil) barındıran bir bilgisayar sanallaştırmasıdır. **Container** ise host'un **kernel'ini paylaşır**; yalnızca uygulamayı ve bağımlılıklarını yalıtır.\n\nBu farkın sonuçları:\n- **Boyut:** VM imajları gigabaytlarca, container imajları genelde megabaytlarca.\n- **Başlama süresi:** VM dakikalar içinde açılır, container saniyeler hatta milisaniyeler içinde başlar.\n- **Yoğunluk:** Aynı sunucuda çok daha fazla container çalıştırılabilir.\n\nYalıtım Linux kernel özellikleriyle sağlanır: **namespace**'ler (container'ın göreceği süreçleri, ağı, dosya sistemini ayırır) ve **cgroup**'lar (CPU ve bellek kullanımını sınırlar).\n\nSık atlanan nokta: kernel paylaşıldığı için container yalıtımı VM kadar güçlü değildir. Kernel'deki bir açık tüm container'ları etkileyebilir; güvenlik sınırının kritik olduğu yerlerde VM tercih edilir. Ayrıca Linux container'ları Windows/Mac'te doğrudan değil, arka planda çalışan hafif bir Linux VM içinde çalışır.", + "modelAnswer": "Sanal makine hypervisor üzerinde kendi kernel'i dahil tam bir işletim sistemi çalıştırır; container ise host'un kernel'ini paylaşır ve yalnızca uygulamayı ve bağımlılıklarını yalıtır. Bu yüzden container image'ları genelde megabaytlarla ölçülür, container saniyeler içinde başlar ve aynı sunucuda çok daha fazla container çalıştırılabilir. Yalıtımı Linux kernel'inin namespace'leri (süreç, ağ ve dosya sistemi görünümü) ve cgroup'ları (CPU ve bellek sınırı) sağlar. Kernel paylaşıldığı için bu yalıtım VM kadar güçlü değildir; kernel'deki bir açık bütün container'ları etkileyebilir, güvenlik sınırının kritik olduğu yerde VM tercih edilir.", "keyConcepts": [ { "id": "tam-os", @@ -219,7 +219,7 @@ "followUps": [ "Docker Desktop Windows'ta Linux container'larını nasıl çalıştırır?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: What is a container? (Containers versus virtual machines), Docker overview (The underlying technology), Resource constraints" }, { "id": "docker-layer-cache", @@ -228,7 +228,7 @@ "topic": "Dockerfile", "difficulty": 2, "prompt": "Dockerfile'da katman önbelleği (layer cache) nasıl çalışır? Talimatların sırası build süresini neden etkiler?", - "modelAnswer": "Dockerfile'daki dosya sistemini değiştiren her talimat (RUN, COPY, ADD) bir **katman** üretir. Docker bir talimatı tekrar çalıştırmadan önce **önbellekte** aynı sonucu arar; talimat ve girdileri değişmediyse katmanı yeniden kullanır.\n\nKritik kural: bir katmanın önbelleği **bozulursa, ondan sonraki tüm katmanlar** da yeniden oluşturulur. Bu yüzden sık değişen şeyler en sona, nadiren değişenler başa konur.\n\n```dockerfile\n# Kötü: her kod değişikliği npm install'u tekrar çalıştırır\nCOPY . .\nRUN npm ci\n\n# İyi: bağımlılıklar yalnızca package dosyaları değişince kurulur\nCOPY package.json package-lock.json ./\nRUN npm ci\nCOPY . .\n```\n\nJava'da aynı mantık `pom.xml` kopyalanıp `mvn dependency:go-offline` çalıştırılarak, sonra kaynak kodu kopyalanarak uygulanır.\n\nSık atlanan nokta: `RUN apt-get update` tek başına bir katmanda kalırsa eski önbellekle eski paket listesi kullanılabilir. `apt-get update && apt-get install ...` aynı RUN içinde yazılmalıdır.", + "modelAnswer": "Dockerfile'da dosya sistemini değiştiren her talimat (RUN, COPY, ADD) bir katman üretir; Docker bir talimatı çalıştırmadan önce önbellekte aynı sonucu arar ve talimatla girdileri değişmediyse katmanı yeniden kullanır. Bir katman değiştiğinde ondan sonraki tüm katmanlar da yeniden oluşturulur, bu yüzden pahalı ve nadiren değişen adımlar başa, sık değişenler en sona konur. Tipik örnek, önce yalnızca `package.json` ile lock dosyasını kopyalayıp bağımlılıkları kurmak, kaynak kodu sonra kopyalamaktır; Java'da aynı sırayı `pom.xml` sağlar. `apt-get update` ayrı bir RUN'da kalırsa önbellekteki eski paket listesi kullanılabilir, bu yüzden `apt-get install` ile aynı RUN içinde yazılır.", "keyConcepts": [ { "id": "talimat-katman", @@ -291,7 +291,7 @@ "followUps": [ "Önbelleği tamamen yok sayarak build almak için ne yaparsın, ne zaman gerekir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Docker build cache, Optimize cache usage in builds (Order your layers), Building best practices (apt-get)" }, { "id": "docker-multi-stage", @@ -300,7 +300,7 @@ "topic": "Dockerfile", "difficulty": 2, "prompt": "Multi-stage build nedir ve ne işe yarar? Bir Spring Boot uygulaması için örnek ver.", - "modelAnswer": "Multi-stage build, tek Dockerfile içinde **birden fazla FROM** kullanarak derleme ve çalıştırma ortamlarını ayırmaktır. İlk aşamada derleme araçlarıyla uygulama derlenir, son aşamaya yalnızca **çıktı (artifact)** kopyalanır.\n\n```dockerfile\nFROM maven:3.9-eclipse-temurin-21 AS build\nWORKDIR /app\nCOPY pom.xml .\nRUN mvn dependency:go-offline\nCOPY src ./src\nRUN mvn package -DskipTests\n\nFROM eclipse-temurin:21-jre\nWORKDIR /app\nCOPY --from=build /app/target/app.jar app.jar\nENTRYPOINT [\"java\", \"-jar\", \"app.jar\"]\n```\n\nFaydaları:\n- **Küçük image:** Son image'da Maven, JDK ve kaynak kod yoktur, yalnızca JRE ve jar vardır.\n- **Güvenlik:** Derleme araçları canlı image'da olmadığı için saldırı yüzeyi küçülür.\n- **Tek Dockerfile:** Derleme için ayrı bir script veya CI adımı gerekmez.\n\nSık atlanan nokta: ara aşamaların katmanları son image'a girmez, ama build sırasında önbellek için tutulur. Build'i hızlı tutmak için katman sırası kuralı ara aşamalarda da geçerlidir.", + "modelAnswer": "Multi-stage build, tek Dockerfile'da birden fazla FROM kullanarak derleme ve çalıştırma ortamını ayırmaktır; her FROM yeni bir aşama başlatır ve son image'a yalnızca seçilen çıktı kopyalanır. Spring Boot için ilk aşama `maven:3.9-eclipse-temurin-21 AS build` gibi bir image'da `mvn package` ile jar'ı üretir, ikinci aşama `eclipse-temurin:21-jre` üzerinde `COPY --from=build` ile yalnızca bu jar dosyasını alır ve `java -jar` ile başlatır. Son image'da Maven, JDK ve kaynak kod olmadığı için image küçülür ve derleme araçları canlıda bulunmadığından saldırı yüzeyi daralır. Ara aşamalardaki her talimat da build önbelleğinde bir katman olduğu için katman sırası kuralı o aşamalarda da geçerlidir.", "keyConcepts": [ { "id": "birden-fazla-from", @@ -308,7 +308,8 @@ "aliases": [ "birden fazla from", "iki from", - "aşama", + "aşamada", + "aşamalı", "as build" ], "anchors": [ @@ -360,7 +361,7 @@ "followUps": [ "Son aşamada distroless image kullanmanın artısı ve eksisi nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Multi-stage builds, Docker build cache" }, { "id": "docker-cmd-vs-entrypoint", @@ -369,7 +370,7 @@ "topic": "Dockerfile", "difficulty": 2, "prompt": "CMD ile ENTRYPOINT arasındaki fark nedir? Exec form ile shell form farkı neden önemlidir?", - "modelAnswer": "**ENTRYPOINT** container başladığında çalışacak **ana komutu** belirler. **CMD** ise varsayılan komutu ya da ENTRYPOINT'e verilecek **varsayılan argümanları** belirler.\n\nFark `docker run` sırasında ortaya çıkar: `docker run image ` yazıldığında **CMD tamamen değiştirilir**, ENTRYPOINT ise korunur ve argümanlar ona eklenir. ENTRYPOINT'i değiştirmek için `--entrypoint` bayrağı gerekir.\n\n```dockerfile\nENTRYPOINT [\"java\", \"-jar\", \"app.jar\"]\nCMD [\"--spring.profiles.active=prod\"]\n```\n\nBurada `docker run image --spring.profiles.active=dev` yalnızca profili değiştirir.\n\nİki yazım biçimi vardır:\n- **Exec form** `[\"java\", \"-jar\", \"app.jar\"]`: komut doğrudan **PID 1** olarak çalışır.\n- **Shell form** `java -jar app.jar`: komut `/bin/sh -c` üzerinden çalışır; PID 1 shell olur.\n\nSık atlanan nokta: shell formda shell, `docker stop`'un gönderdiği **SIGTERM** sinyalini uygulamaya iletmez. Uygulama düzgün kapanamaz, 10 saniye sonra SIGKILL ile öldürülür. Bu yüzden exec form tercih edilmelidir.", + "modelAnswer": "ENTRYPOINT container başladığında çalışacak ana komutu, CMD ise varsayılan komutu ya da ENTRYPOINT'e eklenecek varsayılan argümanları belirler. `docker run image ` yazıldığında CMD tamamen değiştirilir, ENTRYPOINT korunur ve argümanlar ona eklenir; ENTRYPOINT'i değiştirmek için `--entrypoint` bayrağı gerekir. Örneğin ENTRYPOINT `java -jar app.jar`, CMD bir Spring profili olursa `docker run` yalnızca profili değiştirebilir. Exec form (JSON dizi) komutu doğrudan PID 1 olarak çalıştırır, shell form ise `/bin/sh -c` üzerinden çalıştırdığı için `docker stop`'un gönderdiği SIGTERM uygulamaya ulaşmaz ve uygulama varsayılan 10 saniyelik sürenin sonunda SIGKILL ile öldürülür.", "keyConcepts": [ { "id": "entrypoint-ana", @@ -432,7 +433,7 @@ "followUps": [ "Container başlarken önce bir hazırlık script'i çalıştırıp sonra uygulamayı başlatmak istersen ENTRYPOINT'i nasıl yazarsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Dockerfile reference (CMD, ENTRYPOINT, Understand how CMD and ENTRYPOINT interact), docker container stop" }, { "id": "docker-copy-vs-add", @@ -441,7 +442,7 @@ "topic": "Dockerfile", "difficulty": 1, "prompt": "COPY ile ADD arasındaki fark nedir? Hangisini tercih edersin?", - "modelAnswer": "İkisi de dosyaları build context'inden image'a kopyalar. **ADD** iki ek özelliğe sahiptir:\n- Yerel bir **tar arşivini otomatik olarak açar**.\n- **URL**'den dosya indirebilir.\n\n**COPY** ise yalnızca kopyalar, başka bir şey yapmaz.\n\nTercih edilen **COPY**'dir, çünkü davranışı açık ve öngörülebilirdir. ADD ile bir `.tar.gz` kopyalandığında beklenmedik şekilde açılması gibi sürprizler olur.\n\nURL'den indirme için de ADD yerine `RUN curl` (veya `wget`) daha iyidir: indirme, doğrulama ve gereksiz dosyaları silme aynı RUN içinde yapılabilir ve fazladan katman oluşmaz.\n\nADD'i yalnızca yerel bir arşivin açılmasını özellikle istediğin durumda kullanırsın.", + "modelAnswer": "İkisi de dosyaları build context'inden image'a kopyalar; COPY yalnızca kopyalar, ADD ise yerel bir tar arşivini otomatik açar ve uzak bir URL'den ya da Git deposundan dosya indirebilir. Yerel dosyalar için COPY tercih edilir, çünkü davranışı öngörülebilirdir; ADD ile kopyalanan bir `.tar.gz` beklenmedik şekilde açılabilir. Uzak bir dosyayı build sırasında indirmek gerekiyorsa Docker'ın güncel önerisi `RUN curl` ya da `wget` yerine ADD'dir, çünkü build önbelleği daha isabetli çalışır ve `--checksum` ile indirilen içerik doğrulanabilir. Uzak URL'den gelen arşiv otomatik açılmaz, açma yalnızca yerel arşivlerde olur.", "keyConcepts": [ { "id": "ikisi-kopyalar", @@ -505,7 +506,7 @@ "followUps": [ "Build context nedir ve .dockerignore build'i nasıl etkiler?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Building best practices (ADD or COPY), Dockerfile reference (ADD)" }, { "id": "docker-volume-vs-bind", @@ -514,7 +515,7 @@ "topic": "Veri ve depolama", "difficulty": 2, "prompt": "Volume ile bind mount arasındaki fark nedir? Bir veritabanı container'ı için hangisini kullanırsın?", - "modelAnswer": "Container'ın yazılabilir katmanı container silinince kaybolduğu için kalıcı veri dışarıda tutulur. İki ana yol vardır:\n\n- **Volume:** Docker tarafından yönetilen depolamadır (Linux'ta `/var/lib/docker/volumes` altında). İsimle oluşturulur ve yönetilir (`docker volume create`, `docker volume ls`). Host'un klasör yapısından bağımsızdır.\n- **Bind mount:** Host'taki **belirli bir klasörü** container'a bağlar (`-v /home/mete/app:/app`). Host'taki değişiklik container'da anında görünür.\n\n**Veritabanı için volume** kullanılır: Docker yönetir, yedeklemesi ve taşınması kolaydır, host'un dosya izinleriyle uğraşmak gerekmez ve Docker Desktop'ta performansı bind mount'tan iyidir.\n\n**Bind mount** ise geliştirmede kaynak kodu container'a bağlayıp anında yansıtmak (hot reload) veya bir konfigürasyon dosyasını vermek için uygundur.\n\nSık atlanan nokta: `docker compose down -v` veya `docker volume prune` volume'ları da siler. Veritabanı volume'u yanlışlıkla silinirse veri gider; canlıda volume yedeklemesi ayrıca planlanmalıdır.", + "modelAnswer": "Container'ın yazılabilir katmanı container silinince kaybolduğu için kalıcı veri dışarıda tutulur. Volume, Docker tarafından yönetilen ve host'ta Docker'ın kendi dizininde (Linux'ta genelde `/var/lib/docker/volumes`) duran depolamadır; bind mount ise host'taki belirli bir klasörü ya da dosyayı container'a bağlar. Veritabanı için volume kullanılır, çünkü Docker CLI ile yönetilir, yedeklenmesi ve taşınması bind mount'tan kolaydır ve host'un klasör yapısına bağlı değildir; bind mount ise geliştirmede kaynak kodu ya da bir konfigürasyon dosyasını container'la paylaşmak için uygundur. `docker compose down -v` Compose dosyasında tanımlı named volume'ları, `docker volume prune -a` da kullanılmayan bütün volume'ları sildiği için veritabanı volume'u yanlışlıkla silinebilir; canlıda yedekleme ayrıca planlanır.", "keyConcepts": [ { "id": "kalici", @@ -588,7 +589,7 @@ "followUps": [ "Bir PostgreSQL volume'unun yedeğini nasıl alırsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Volumes, Bind mounts, Storage drivers, docker compose down, docker volume prune" }, { "id": "docker-expose-vs-publish", @@ -597,7 +598,7 @@ "topic": "Ağ", "difficulty": 1, "prompt": "Dockerfile'daki EXPOSE ile docker run'daki port yayınlama (-p) arasındaki fark nedir?", - "modelAnswer": "**EXPOSE** yalnızca **belgeleme** amaçlıdır: image'ın hangi portu dinlediğini bildirir ama portu dışarıya açmaz. Tek başına hiçbir erişim sağlamaz.\n\n**Port yayınlama** (`-p 8080:80`) ise host'un bir portunu container'ın bir portuna **gerçekten bağlar**. Soldaki host portu, sağdaki container portudur; host'ta 8080'e gelen istek container'ın 80 portuna gider.\n\nÖnemli ayrıntı: `-p 8080:80` varsayılan olarak host'un **tüm arayüzlerinde** (0.0.0.0) dinler, yani servis internete açılabilir. Yalnızca sunucunun kendisinden (ör. önündeki nginx'ten) erişilmesi isteniyorsa `-p 127.0.0.1:8080:80` yazılır.\n\nSık atlanan nokta: Linux'ta Docker yayınlanan portlar için kendi iptables kurallarını ekler ve bu kurallar **UFW gibi güvenlik duvarlarını atlar**. \"UFW'de portu kapattım\" diye düşünülen bir veritabanı portu internete açık kalabilir. Çözüm, portu yalnızca 127.0.0.1'e bağlamak veya hiç yayınlamamaktır.", + "modelAnswer": "EXPOSE yalnızca belgeleme amaçlıdır; image'ın hangi portu dinlediğini bildirir ama portu dışarı açmaz. `-p 8080:80` ise host'un 8080 portunu container'ın 80 portuna gerçekten bağlar, soldaki host portu sağdaki container portudur. Adres verilmezse Docker portu host'un tüm arayüzlerinde (`0.0.0.0` ve `[::]`) yayınlar, yani servis dışarıya açılır; yalnızca sunucunun kendisinden erişilecekse `-p 127.0.0.1:8080:80` yazılır. Linux'ta Docker yayınlanan portlar için kendi güvenlik duvarı kurallarını ekler ve bu trafik UFW gibi araçların kurallarından önce yönlendirildiği için UFW'de kapatıldığı sanılan bir port açık kalabilir.", "keyConcepts": [ { "id": "expose-belge", @@ -659,7 +660,7 @@ "followUps": [ "Container'ın yayınlanmış portlarını hangi komutla görürsün?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Dockerfile reference (EXPOSE), Port publishing and mapping, Packet filtering and firewalls (Docker and ufw)" }, { "id": "docker-compose", @@ -668,7 +669,7 @@ "topic": "Compose", "difficulty": 1, "prompt": "Docker Compose nedir ve ne işe yarar?", - "modelAnswer": "Docker Compose, birden fazla container'dan oluşan bir uygulamayı **tek bir YAML dosyasında** (`compose.yaml` / `docker-compose.yml`) tanımlayıp **tek komutla** yönetmeyi sağlayan araçtır.\n\n```yaml\nservices:\n backend:\n build: ./backend\n ports: [\"127.0.0.1:8080:8080\"]\n environment:\n SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/app\n depends_on: [db]\n db:\n image: postgres:16\n volumes: [\"pgdata:/var/lib/postgresql/data\"]\nvolumes:\n pgdata:\n```\n\nTemel komutlar: `docker compose up -d` (hepsini başlat), `docker compose down` (durdur ve sil), `docker compose logs -f backend` (logları izle).\n\nCompose tüm servisleri **ortak bir ağa** koyar; servisler birbirine **servis adıyla** erişir. Yukarıdaki örnekte backend veritabanına `db` hostname'i ile bağlanır.\n\nSık atlanan nokta: Compose tek bir sunucu içindir. Birden fazla sunucuya yayılma, otomatik ölçekleme ve kendini iyileştirme gerekiyorsa Kubernetes gibi bir orkestrasyon aracı gerekir.", + "modelAnswer": "Docker Compose, birden fazla container'dan oluşan bir uygulamanın servislerini, ağlarını ve volume'larını tek bir YAML dosyasında (`compose.yaml`) tanımlayıp tek komutla yönetmeyi sağlar. `docker compose up -d` bütün servisleri başlatır, `docker compose down` servisleri durdurup container'ları ve ağı kaldırır. Compose varsayılan olarak uygulama için ortak bir ağ kurar ve her servis bu ağda servis adıyla bulunur; örneğin backend veritabanına `db` adıyla bağlanır. En kolay kullanım tek sunucudur; birden fazla sunucuya yayılmak ve ölçekleme için Swarm ya da Kubernetes gibi bir orkestrasyon katmanı gerekir.", "keyConcepts": [ { "id": "yaml", @@ -712,7 +713,9 @@ "id": "tek-sunucu", "label": "Tek sunucu için", "aliases": [ - "tek sunucu", + "tek bir sunucu", + "tek sunucuda", + "tek sunucudur", "kubernetes", "orkestrasyon", "ölçekleme" @@ -725,7 +728,7 @@ "followUps": [ "Compose'ta up ile up --build arasındaki fark nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Compose application model, Networking in Compose, Use Compose in production" }, { "id": "docker-depends-on-healthcheck", @@ -734,7 +737,7 @@ "topic": "Compose", "difficulty": 2, "prompt": "Compose'ta backend, veritabanından önce ayağa kalkıp bağlanamıyor. depends_on bunu neden çözmez ve doğru çözüm nedir?", - "modelAnswer": "Varsayılan `depends_on` yalnızca **başlatma sırasını** belirler: db container'ı **başlatıldıktan** sonra backend başlatılır. Ama container'ın başlamış olması, içindeki PostgreSQL'in bağlantı **kabul etmeye hazır** olduğu anlamına gelmez; veritabanının açılması birkaç saniye sürebilir.\n\nDoğru çözüm, veritabanına bir **healthcheck** tanımlayıp backend'i onun **sağlıklı** olmasına bağlamaktır:\n\n```yaml\nservices:\n db:\n image: postgres:16\n healthcheck:\n test: [\"CMD-SHELL\", \"pg_isready -U app\"]\n interval: 5s\n retries: 10\n backend:\n depends_on:\n db:\n condition: service_healthy\n```\n\nEk olarak uygulamanın kendisi de bağlantı hatasına dayanıklı olmalıdır (bağlantı havuzunun yeniden denemesi gibi). Veritabanı sonradan yeniden başlarsa depends_on işe yaramaz; o anda uygulamanın yeniden bağlanabilmesi gerekir.", + "modelAnswer": "Varsayılan `depends_on` yalnızca başlatma sırasını belirler; Compose bağımlılığın hazır olmasını değil yalnızca çalışmaya başlamasını bekler, oysa container'ı açılmış bir PostgreSQL'in bağlantı kabul etmeye başlaması birkaç saniye sürebilir. Doğru çözüm veritabanına `pg_isready` çalıştıran bir healthcheck tanımlayıp backend'in `depends_on` kaydına `condition: service_healthy` yazmaktır; böylece backend ancak veritabanı sağlıklı olduğunda başlatılır. Bu yalnızca açılıştaki sırayı çözer; veritabanı sonradan yeniden başlarsa `depends_on` bir şey yapmaz, bu yüzden uygulamanın kendisi de bağlantı hatasına dayanıklı olmalı ve bağlantı havuzu yeniden denemelidir.", "keyConcepts": [ { "id": "sadece-sira", @@ -780,7 +783,7 @@ "label": "condition: service_healthy", "aliases": [ "service_healthy", - "condition", + "condition:", "sağlıklı" ], "anchors": [ @@ -804,7 +807,7 @@ "followUps": [ "Spring Boot uygulaması için healthcheck'i neyle yazarsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Control startup and shutdown order in Compose" }, { "id": "docker-env-secrets", @@ -813,7 +816,7 @@ "topic": "Güvenlik", "difficulty": 2, "prompt": "Veritabanı şifresi gibi gizli bilgileri bir container'a nasıl verirsin? Neler yapılmamalıdır?", - "modelAnswer": "Yapılmaması gerekenler:\n- Şifreyi **Dockerfile'a** (`ENV DB_PASSWORD=...`) veya image'a kopyalanan bir dosyaya yazmak. Image'ı çeken herkes `docker history` veya `docker inspect` ile görür; image katmanlarından silinmiş gibi görünse bile önceki katmanda durur.\n- Şifreyi **git reposuna** commit etmek.\n\nDoğru yollar:\n- **Çalışma anında environment variable** vermek: `docker run -e` veya Compose'ta `env_file: .env`. `.env` dosyası `.gitignore`'a eklenir ve sunucuda tutulur.\n- **Docker secrets** (Swarm/Compose): şifre container'a `/run/secrets/` altında dosya olarak bağlanır, environment'ta görünmez.\n- Büyük sistemlerde **Vault** veya bulut sağlayıcının secret manager'ı.\n\nSık atlanan nokta: environment variable'lar da tamamen gizli değildir; `docker inspect` çıktısında ve bazen hata loglarında görünür. Yüksek güvenlik gereken yerlerde dosya tabanlı secret tercih edilir. Build sırasında gizli bilgi gerekiyorsa (özel bir paket deposu gibi) `RUN --mount=type=secret` kullanılır, böylece katmana yazılmaz.", + "modelAnswer": "Şifre Dockerfile'a `ENV` ile ya da image'a kopyalanan bir dosyaya yazılmaz, çünkü image'a gömülür ve image'ı çeken herkes `docker history` ya da `docker image inspect` ile görebilir, sonraki bir katmanda silinen dosya da önceki image katmanında durur; aynı şekilde git reposuna da commit edilmez. En basit yol şifreyi çalışma anında ortam değişkeni olarak vermektir (`docker run -e` ya da Compose'ta `env_file` ile, `.gitignore`'a eklenmiş bir `.env` dosyasından). Ortam değişkenleri de tam gizli değildir, container'daki bütün süreçler görebilir ve hata ayıklarken loglara düşebilir; bu yüzden Compose secret'ları tercih edilir, şifre container'a `/run/secrets/` altında dosya olarak bağlanır. Build sırasında gerekiyorsa `RUN --mount=type=secret` kullanılır, böylece şifre yalnızca o talimat süresince erişilebilir olur ve image'da kalmaz; büyük sistemlerde Vault gibi bir secret yöneticisi devreye girer.", "keyConcepts": [ { "id": "dockerfile-yok", @@ -872,7 +875,7 @@ "followUps": [ "Environment variable'ların docker inspect çıktısında görünmesi neden risklidir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Secrets in Compose, Build secrets, Building best practices" }, { "id": "docker-image-size", @@ -881,7 +884,7 @@ "topic": "Dockerfile", "difficulty": 2, "prompt": "Bir Docker image'ının boyutunu nasıl küçültürsün?", - "modelAnswer": "Image küçüldükçe çekme (pull) ve deploy hızlanır, depolama azalır ve saldırı yüzeyi küçülür. Yöntemler:\n\n- **Küçük base image:** `eclipse-temurin:21` yerine `eclipse-temurin:21-jre` veya **alpine**/**distroless** varyantları. JDK yerine yalnızca JRE yeterlidir.\n- **Multi-stage build:** Derleme araçları ve kaynak kod son image'a girmez.\n- **RUN komutlarını birleştirmek ve aynı katmanda temizlemek:** Temizlik ayrı bir RUN'da yapılırsa dosyalar önceki katmanda kalır ve boyut düşmez.\n- **.dockerignore:** `node_modules`, `.git`, `target` gibi klasörlerin build context'e girmesini engeller.\n\nPaket kurulumu ve temizlik aynı RUN içinde:\n\n```dockerfile\nRUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*\n```\n\nBoyutun nereden geldiğini görmek için `docker history ` her katmanın boyutunu gösterir.\n\nSık atlanan nokta: alpine **musl libc** kullanır; bazı native kütüphanelerle (bazı Python paketleri, bazı JVM araçları) uyumsuzluk çıkarabilir. Küçük olması her zaman doğru seçim olduğu anlamına gelmez.", + "modelAnswer": "Image küçüldükçe çekme ve deploy hızlanır, depolama azalır ve saldırı yüzeyi küçülür. İlk adım küçük bir base image seçmektir, örneğin JDK yerine `eclipse-temurin:21-jre` ya da alpine veya distroless bir varyant; multi-stage build da derleme araçlarını ve kaynak kodu son image'ın dışında bırakır. Temizlik kurulumla aynı RUN içinde yapılmalıdır (`apt-get install` ardından `rm -rf /var/lib/apt/lists/*`), çünkü ayrı bir katmanda silinen dosya önceki katmanda durmaya devam eder; `.dockerignore` da `node_modules`, `.git` ve `target` gibi klasörleri build context'in dışında tutar. Boyutun hangi katmandan geldiğini `docker history` gösterir; alpine'ın glibc yerine musl libc kullandığı da unutulmamalıdır, glibc'ye göre derlenmiş native kütüphaneler orada çoğu zaman çalışmaz.", "keyConcepts": [ { "id": "base", @@ -890,7 +893,8 @@ "base image", "alpine", "distroless", - "slim", + "-slim", + "slim image", "-jre" ], "anchors": [ @@ -902,7 +906,8 @@ "label": "Multi-stage build", "aliases": [ "multi-stage", - "aşama" + "multi stage", + "aşamalı" ], "anchors": [ "Multi-stage build ile derleme araçları son image'a girmez." @@ -949,7 +954,7 @@ "followUps": [ "Distroless image kullanan bir container'da hata ayıklamak neden zordur?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Building best practices (base image, multi-stage builds, apt-get, .dockerignore); Docker Hub: alpine; musl libc FAQ" }, { "id": "docker-debug-container", @@ -958,7 +963,7 @@ "topic": "Hata ayıklama", "difficulty": 1, "prompt": "Bir container hata veriyor veya beklenmedik davranıyor. Sorunu bulmak için hangi komutları kullanırsın?", - "modelAnswer": "Adım adım:\n\n1. **`docker ps -a`**: Container çalışıyor mu, durduysa **exit code** ne? `-a` durmuş container'ları da gösterir.\n2. **`docker logs `**: Uygulamanın stdout/stderr çıktısı. `-f` ile canlı izlenir, `--tail 100` ile son satırlar alınır. Çoğu sorun burada görünür.\n3. **`docker exec -it sh`**: Çalışan container'ın içine girip dosyalara, ortam değişkenlerine, ağa bakmak. (bash olmayan imajlarda `sh`.)\n4. **`docker inspect `**: Ayrıntılı yapılandırma; environment variable'lar, mount'lar, ağ ve IP, restart sayısı, son çıkış nedeni.\n5. **`docker stats`**: Anlık CPU ve bellek kullanımı; bellek sınırına dayanıyor mu?\n\nExit code ipucu verir: **137** genelde bellek yetmediği için kernel tarafından öldürüldüğünü (**OOMKilled**, `docker inspect`'te görünür) ya da SIGKILL aldığını, **1** uygulama hatasını, **0** normal bitişi gösterir.\n\nCompose kullanılıyorsa aynı komutların karşılıkları: `docker compose ps`, `docker compose logs -f backend`, `docker compose exec backend sh`.", + "modelAnswer": "Önce `docker ps -a` ile container'ın çalışıp çalışmadığına ve durduysa çıkış koduna bakılır; `-a` durmuş container'ları da gösterir. Sorunların çoğu uygulamanın stdout ve stderr çıktısında görünür, bunu `docker logs` verir (`-f` ile canlı izlenir). Çalışan container'ın içindeki dosyalara, ortam değişkenlerine ve ağa `docker exec -it sh` ile girip bakılır; mount'lar, ağ ayarları, yeniden başlama sayısı ve son çıkış nedeni gibi ayrıntılı yapılandırmayı `docker inspect`, anlık CPU ve bellek kullanımını `docker stats` gösterir. Çıkış kodu da ipucu verir; 0 normal bitiş, 1 genelde uygulama hatasıdır, 137 (128 + 9) sürecin SIGKILL ile öldürüldüğünü gösterir ve sebep bellek yetmemesiyse `docker inspect` çıktısında OOMKilled true olur.", "keyConcepts": [ { "id": "ps", @@ -1029,7 +1034,7 @@ "followUps": [ "Container içinde shell yoksa (distroless) nasıl hata ayıklarsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: docker container run (Exit status), Docker Engine API (ContainerState); GNU Bash Reference Manual: Exit Status" }, { "id": "docker-exits-immediately", @@ -1038,7 +1043,7 @@ "topic": "Hata ayıklama", "difficulty": 2, "prompt": "Bir container başlatıldıktan hemen sonra kapanıyor. Olası sebepler nelerdir?", - "modelAnswer": "Container, **ana süreci (PID 1) çalıştığı sürece** yaşar. Ana süreç biterse container da durur. Bu yüzden \"hemen kapanıyor\" sorununun sebepleri şunlardır:\n\n- **Ana komut ön planda çalışmıyor:** Servis arka plana (daemon) geçiyorsa ana süreç hemen biter. Örneğin nginx `daemon off;` ile, diğer servisler kendi foreground seçenekleriyle çalıştırılmalıdır.\n- **Komut işini bitirip çıkıyor:** `ubuntu` image'ı varsayılan olarak `bash` çalıştırır; `-it` verilmezse girdi olmadığı için bash hemen çıkar. Bu bir hata değil, beklenen davranıştır.\n- **Uygulama hata verip çöküyor:** Eksik environment variable, bağlanamayan veritabanı, bulunamayan dosya. Exit code 1 olur ve sebep loglardadır.\n- **Yanlış ENTRYPOINT/CMD:** Dosya bulunamıyor, script çalıştırılabilir değil (`chmod +x` unutulmuş) veya Windows'ta yazılmış script'te CRLF satır sonu yüzünden `/bin/sh^M` hatası.\n\nTanı için önce `docker ps -a` ile exit code'a, sonra `docker logs` ile çıktıya bakılır. Log boşsa container'ı komutu ezerek başlatıp içeriden denemek işe yarar: `docker run -it --entrypoint sh `.", + "modelAnswer": "Container'ın ana süreci Dockerfile'daki ENTRYPOINT ve/veya CMD'dir; ana süreç (PID 1) biterse container da durur. En sık sebep servisin arka plana (daemon) geçmesidir, ana süreç hemen biter, bu yüzden nginx gibi servisler ön planda çalıştırılmalıdır; `ubuntu` gibi bash çalıştıran bir image da `-it` verilmezse girdi olmadığı için hemen çıkar ve bu bir hata değildir. Uygulama da eksik environment değişkeni ya da bağlanamayan bir veritabanı yüzünden çöküyor olabilir, o zaman çıkış kodu genelde 1'dir ve sebep loglardadır. Komut bulunamazsa Docker 127, çalıştırılamazsa 126 döner; script'in çalıştırılabilir olmaması (`chmod +x` unutulmuş) ya da Windows'ta yazılmış bir script'in CRLF satır sonu taşıması da container'ı başlar başlamaz düşürür. Tanı için önce `docker ps -a` ile çıkış koduna, sonra `docker logs` ile çıktıya bakılır; log boşsa `docker run -it --entrypoint sh ` ile içeriden denenir.", "keyConcepts": [ { "id": "pid1", @@ -1057,7 +1062,7 @@ "id": "foreground", "label": "Ön planda çalışmalı", "aliases": [ - "ön plan", + "ön planda", "foreground", "daemon", "arka plan" @@ -1110,7 +1115,7 @@ "followUps": [ "Windows'ta geliştirip Linux container'ında çalıştırılan script'lerde CRLF sorununu kalıcı olarak nasıl önlersin?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Run multiple processes in a container, Running containers (Exit status), docker container run" }, { "id": "docker-restart-policy", @@ -1119,7 +1124,7 @@ "topic": "Çalıştırma", "difficulty": 1, "prompt": "Restart policy nedir? Seçenekleri nelerdir ve canlıda hangisini kullanırsın?", - "modelAnswer": "Restart policy, container durduğunda Docker'ın onu **otomatik olarak yeniden başlatıp başlatmayacağını** belirler:\n\n- **no** (varsayılan): Hiç yeniden başlatma.\n- **on-failure[:N]**: Yalnızca **hata ile** (sıfır olmayan exit code) çıkarsa yeniden başlat; isteğe bağlı en fazla N kez.\n- **always**: Her durumda yeniden başlat; elle durdurulsa bile Docker servisi yeniden başladığında container da başlar.\n- **unless-stopped**: always gibi, ama **elle durdurulmuşsa** Docker yeniden başladığında başlatmaz.\n\nCanlıda genelde **unless-stopped** kullanılır: sunucu yeniden başlarsa veya uygulama çökerse container geri gelir, ama bakım için bilerek durdurulan bir container kendiliğinden açılmaz.\n\n```yaml\nservices:\n backend:\n restart: unless-stopped\n```\n\nSık atlanan nokta: restart policy sorunu gizleyebilir. Sürekli çöküp yeniden başlayan bir container dışarıdan çalışıyor gibi görünür; `docker ps` çıktısındaki \"Restarting\" durumu ve `docker inspect`'teki RestartCount kontrol edilmelidir.", + "modelAnswer": "Restart policy, container durduğunda Docker'ın onu otomatik olarak yeniden başlatıp başlatmayacağını belirler; varsayılan `no` hiç yeniden başlatmaz. `on-failure[:N]` yalnızca sıfır olmayan bir çıkış koduyla, yani hata ile çıkıldığında ve isteğe bağlı en fazla N kez yeniden başlatır; `always` her durumda yeniden başlatır ve elle durdurulan container'ı da Docker servisi yeniden başladığında geri getirir, `unless-stopped` ise elle durdurulmuş container'ı servis yeniden başlasa bile başlatmaz. Canlıda genelde `unless-stopped` kullanılır, çünkü sunucu yeniden başlarsa ya da uygulama çökerse container geri gelir ama bakım için bilerek durdurulan container kendiliğinden açılmaz. Policy ancak container en az 10 saniye ayakta kaldıktan sonra devreye girer; bundan sonra tekrar tekrar çöken bir container dışarıdan çalışıyor gibi görünüp sorunu gizleyebileceği için `docker ps`'teki Restarting durumu ve `docker inspect`'teki RestartCount takip edilir.", "keyConcepts": [ { "id": "otomatik", @@ -1175,7 +1180,7 @@ "followUps": [ "Docker servisinin kendisi sunucu açılışında başlamazsa restart policy işe yarar mı?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Start containers automatically, Docker Engine API (RestartCount)" }, { "id": "docker-resource-limits", @@ -1184,7 +1189,7 @@ "topic": "Çalıştırma", "difficulty": 3, "prompt": "Bir container'ın bellek ve CPU kullanımını nasıl sınırlarsın? Java uygulamalarında nelere dikkat etmek gerekir?", - "modelAnswer": "Varsayılan olarak bir container host'un **tüm belleğini ve CPU'sunu** kullanabilir; bir container'daki bellek sızıntısı tüm sunucuyu etkiler. Sınırlar cgroup'lar üzerinden konur:\n\n```bash\ndocker run --memory=512m --cpus=1.5 myapp\n```\n\nCompose'ta `deploy.resources.limits` altında `memory` ve `cpus` olarak verilir.\n\nBellek sınırı aşılırsa kernel container'ı **OOM killer** ile öldürür; exit code **137** olur ve `docker inspect`'te `OOMKilled: true` görünür. CPU sınırı aşıldığında ise container öldürülmez, **yavaşlatılır** (throttling).\n\nJava'da dikkat edilecekler:\n- Modern JVM'ler (JDK 10+) **container farkındadır**; heap boyutunu host belleğine değil container sınırına göre hesaplar.\n- Varsayılan maksimum heap sınırın yalnızca **%25**'idir. Bu çoğu zaman azdır; `-XX:MaxRAMPercentage=75` ile artırılır.\n- Heap'i sınırın tamamına eşitlemek hatadır: JVM heap dışında da bellek kullanır (metaspace, thread stack'leri, direct buffer). Heap sınıra çok yakınsa container yine OOM ile öldürülür.", + "modelAnswer": "Varsayılan olarak bir container'ın kaynak sınırı yoktur, host'un tüm belleğini ve CPU'sunu kullanabilir; bu yüzden tek bir container'daki bellek sızıntısı bütün sunucuyu etkileyebilir. Sınırlar `docker run --memory=512m --cpus=1.5` gibi bayraklarla ya da Compose'ta `deploy.resources.limits` altında verilir ve Docker bunları container'ın cgroup ayarlarına yazar. Bellek sınırı aşılırsa kernel container'daki süreci OOM killer ile öldürür, çıkış kodu 137 olur ve `docker inspect` OOMKilled'ı gösterir; CPU sınırında ise container öldürülmez, yavaşlatılır (throttling). Java'da güncel JVM'ler Linux'ta varsayılan olarak container farkındadır ve heap'i container'ın bellek sınırına göre hesaplar, ama varsayılan en büyük heap sınırın yalnızca %25'idir ve çoğu zaman `-XX:MaxRAMPercentage=75` gibi bir değerle artırılır. Heap'i sınırın tamamına eşitlemek hatadır, çünkü JVM heap dışında da metaspace, thread stack'leri ve direct buffer için bellek kullanır ve container yine OOM ile öldürülür.", "keyConcepts": [ { "id": "varsayilan", @@ -1219,7 +1224,7 @@ "137", "oom killer", "oomkilled", - "öldür" + "oom ile" ], "anchors": [ "Bellek sınırı aşılınca container OOM killer ile öldürülür." @@ -1257,7 +1262,7 @@ "followUps": [ "Container'ın bellek kullanımını anlık olarak nasıl izlersin?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Resource constraints, Compose Deploy Specification (resources); Oracle Java SE 21: java komutu (UseContainerSupport, MaxRAMPercentage)" }, { "id": "docker-non-root", @@ -1266,7 +1271,7 @@ "topic": "Güvenlik", "difficulty": 2, "prompt": "Container içinde uygulamayı neden root kullanıcısıyla çalıştırmamalısın? Nasıl önlersin?", - "modelAnswer": "Docker image'ları varsayılan olarak **root** kullanıcısıyla çalışır. Container yalıtılmış olsa da kernel paylaşıldığı için, uygulamadaki bir açıktan container'a giren saldırgan root yetkisiyle **container'dan kaçma** (container escape) açıklarını kullanabilir veya bağlı volume'lardaki dosyalara tam yetkiyle erişebilir.\n\nÇözüm Dockerfile'da yetkisiz bir kullanıcı oluşturup ona geçmektir:\n\n```dockerfile\nFROM eclipse-temurin:21-jre\nRUN useradd --system --uid 1001 app\nWORKDIR /app\nCOPY --chown=app:app app.jar .\nUSER app\nENTRYPOINT [\"java\", \"-jar\", \"app.jar\"]\n```\n\nBu, **en az yetki** (least privilege) ilkesinin uygulamasıdır.\n\nEk önlemler: `--read-only` ile container dosya sistemini salt okunur yapmak, `--cap-drop ALL` ile gereksiz Linux yetkilerini kaldırmak ve `--privileged` bayrağını gerçekten gerekmedikçe kullanmamak.\n\nSık atlanan nokta: root olmayan kullanıcı 1024'ün altındaki portları dinleyemez. Uygulama 80 yerine 8080 gibi bir portu dinlemeli, dışarıya port eşlemesiyle 80 olarak sunulmalıdır.", + "modelAnswer": "Container'daki varsayılan kullanıcı root'tur (UID 0); Docker container'ı kısıtlı bir yetki kümesiyle başlatsa da kernel paylaşıldığı için, uygulamadaki bir açıktan giren saldırgan root yetkisiyle container'dan kaçma açıklarını deneyebilir ya da bağlı host klasörlerindeki dosyalara tam yetkiyle yazabilir. Çözüm Dockerfile'da `useradd` ile yetkisiz bir kullanıcı oluşturmak, dosyaları ona `COPY --chown` ile vermek ve `USER` talimatıyla o kullanıcıya geçmektir; bu en az yetki ilkesinin uygulamasıdır. Ek önlem olarak `--read-only` ile kök dosya sistemi salt okunur yapılır, `--cap-drop ALL` ile gereksiz Linux yetkileri kaldırılır ve `--privileged` gerçekten gerekmedikçe kullanılmaz. Eskiden root olmayan kullanıcı 1024'ün altındaki portları dinleyemezdi; Docker 20.10'dan beri container'ın kendi ağında buna izin veren bir sysctl varsayılan olarak açıktır, ama host ağ modunda host'un kendi ayarı geçerli olduğu için uygulamayı 8080 gibi bir portta çalıştırmak hâlâ en taşınabilir seçimdir.", "keyConcepts": [ { "id": "varsayilan-root", @@ -1335,14 +1340,14 @@ "80 yerine" ], "anchors": [ - "Root olmayan kullanıcı 1024 altındaki portları dinleyemez." + "Docker 20.10'dan beri container ağında root olmayan kullanıcı da 1024 altı portu dinleyebilir; host ağ modunda bu geçerli değildir, 8080 gibi bir port taşınabilir seçimdir." ] } ], "followUps": [ "Bind mount edilmiş bir klasöre root olmayan kullanıcı yazamıyorsa sorunu nasıl çözersin?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Building best practices (USER), Running containers (User, Runtime privilege and Linux capabilities), Docker Engine security, docker container run; Docker Engine 20.10 release notes (moby/moby#41030)" }, { "id": "docker-image-tags", @@ -1351,7 +1356,7 @@ "topic": "Registry ve image", "difficulty": 2, "prompt": "Image tag'leri nasıl çalışır? Canlıda latest tag'ini kullanmak neden risklidir?", - "modelAnswer": "Bir image `repo:tag` biçiminde adlandırılır (`postgres:16.4`). Tag, image'ın belirli bir sürümüne işaret eden **değiştirilebilir bir etikettir**. Tag verilmezse varsayılan olarak **latest** kullanılır.\n\nlatest'ın sorunları:\n- **\"En yeni\" anlamına gelmez**, yalnızca tag verilmeden push edilen image'ın adıdır.\n- **Değişkendir:** Aynı `latest` bugün bir sürüme, yarın başka bir sürüme işaret eder. Sunucu image'ı yeniden çektiğinde habersiz bir major sürüm yükseltmesi olabilir (PostgreSQL 16'dan 17'ye geçip mevcut veriyi açamamak gibi).\n- **Geri dönüşü zorlaştırır:** Hangi sürümün çalıştığı belli olmadığı için önceki sürüme dönmek güçleşir.\n\nCanlıda **sabit sürüm tag'i** kullanılır: `postgres:16.4`, kendi uygulaman için semver (`1.4.2`) veya git commit hash'i.\n\nSık atlanan nokta: sabit tag bile teorik olarak üzerine yeniden push edilebilir. Tam garanti için image **digest**'iyle (`postgres@sha256:...`) çekilir; digest içeriğin hash'idir ve değiştirilemez.", + "modelAnswer": "Bir image'ın adı depo adından ve ona eklenen bir tag'den oluşur, örneğin `postgres:16.4`; tag belirli bir image'a işaret eden değiştirilebilir bir etikettir ve tag verilmezse Docker `latest` kullanır. Bu yüzden `latest` en yeni sürüm anlamına gelmez, yalnızca tag verilmeden push edilen image'ın etiketidir ve bugün bir sürüme, yarın başka bir sürüme işaret edebilir. Canlıda sunucu image'ı yeniden çektiğinde habersiz bir major sürüm yükseltmesi olabilir (PostgreSQL 16'dan 17'ye geçip mevcut veri dizinini açamamak gibi) ve hangi sürümün çalıştığı belli olmadığı için önceki sürüme dönmek zorlaşır. Bu yüzden sabit sürüm tag'i (`postgres:16.4`, kendi uygulaman için semver ya da commit hash'i) kullanılır; tag'ler de yeniden push edilebildiği için tam garanti istendiğinde image digest'iyle (`postgres@sha256:...`) çekilir, digest içeriğe bağlıdır ve değişmez.", "keyConcepts": [ { "id": "format", @@ -1387,7 +1392,8 @@ "aliases": [ "habersiz", "major", - "geri dön", + "önceki sürüme", + "eski sürüme", "yükseltme", "hangi sürüm" ], @@ -1414,7 +1420,7 @@ "followUps": [ "Kendi uygulamanın image'ını CI'da nasıl tag'lersin?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: docker image tag, docker image pull (Pull an image by digest), Building best practices (Pin base image versions)" }, { "id": "docker-network-drivers", @@ -1423,7 +1429,7 @@ "topic": "Ağ", "difficulty": 2, "prompt": "Docker'daki ağ sürücüleri (bridge, host, none) arasındaki fark nedir?", - "modelAnswer": "- **bridge** (varsayılan): Container'lar host içinde sanal bir ağa bağlanır ve kendi IP'lerini alır. Dışarıdan erişim için port yayınlama gerekir. **Kullanıcı tanımlı** bridge ağlarında container'lar birbirini adıyla bulur; varsayılan bridge'te bu çalışmaz.\n- **host**: Container **host'un ağını doğrudan kullanır**, ayrı bir ağ yalıtımı yoktur. Container 8080'i dinlerse host'un 8080'i doğrudan açılır, port eşlemesi gerekmez ve ağ katmanı ek yükü olmaz. Bedeli yalıtımın kaybolması ve port çakışmalarıdır. Docker Desktop'ta (Windows/Mac) beklendiği gibi çalışmaz.\n- **none**: Container'ın hiç ağı yoktur, yalnızca loopback vardır. Ağa ihtiyaç duymayan toplu işler veya güvenlik gereği tamamen yalıtılması gereken süreçler için.\n\nBunların yanında birden fazla host'a yayılan **overlay** ağı (Swarm/Kubernetes) vardır.\n\nPratikte çoğu uygulama için doğru seçim, her uygulama grubu için **kullanıcı tanımlı bir bridge** ağıdır; Compose bunu otomatik yapar.", + "modelAnswer": "Varsayılan sürücü bridge'dir; container'lar host içindeki sanal bir ağa bağlanıp kendi IP'lerini alır, dışarıdan erişim için port yayınlama gerekir ve kullanıcı tanımlı bridge ağlarında container'lar birbirini adıyla bulur. host sürücüsünde container ağ yalıtımı olmadan host'un ağını doğrudan kullanır, kendi IP'si olmaz ve `-p` seçenekleri yok sayılır; NAT olmadığı için ek yük yoktur, bedeli yalıtımın kaybolması ve port çakışmalarıdır. Linux'ta Docker Engine host sürücüsünü destekler, Docker Desktop'ta ise 4.34'ten beri ayarlardan açılarak ve yalnızca Linux container'larıyla kullanılabilir. none sürücüsünde container'ın yalnızca loopback arayüzü vardır, ağa ihtiyacı olmayan ya da tamamen yalıtılması gereken işler için kullanılır; birden fazla host'a yayılan ağ gerekiyorsa overlay sürücüsü vardır.", "keyConcepts": [ { "id": "bridge", @@ -1482,9 +1488,9 @@ } ], "followUps": [ - "host ağ modu Docker Desktop'ta neden beklendiği gibi çalışmaz?" + "host ağ modunda çalışan iki container aynı portu dinlemeye çalışırsa ne olur?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: Network drivers, Host network driver, None network driver, Bridge network driver" }, { "id": "docker-registry", @@ -1493,7 +1499,7 @@ "topic": "Registry ve image", "difficulty": 1, "prompt": "Docker registry nedir? Bir image'ı registry'ye nasıl gönderir ve sunucuda nasıl kullanırsın?", - "modelAnswer": "Registry, Docker image'larının **saklandığı ve paylaşıldığı sunucudur**. En bilineni **Docker Hub**'dır; GitHub Container Registry (ghcr.io), AWS ECR, GitLab Registry veya kendi kurduğun özel bir registry de kullanılabilir.\n\nAkış:\n\n```bash\ndocker build -t ghcr.io/kullanici/app:1.4.2 .\ndocker login ghcr.io\ndocker push ghcr.io/kullanici/app:1.4.2\n\n# sunucuda:\ndocker pull ghcr.io/kullanici/app:1.4.2\ndocker run -d ghcr.io/kullanici/app:1.4.2\n```\n\nImage adının başındaki kısım (`ghcr.io/kullanici`) hangi registry'ye gideceğini belirler; registry yazılmazsa Docker Hub varsayılır.\n\nBu akışın faydası: image **bir kez CI'da build edilir**, test edilen aynı image tüm ortamlara (test, canlı) gönderilir. Sunucuda kaynak koddan yeniden build etmek gerekmez ve \"test ettiğim image ile canlıdaki farklı\" riski ortadan kalkar.\n\nSık atlanan nokta: kurumsal ortamlarda (bankalar gibi) internete açık Docker Hub'a erişim genelde kapalıdır; image'lar Nexus veya Artifactory gibi **kurum içi bir registry** üzerinden çekilir.", + "modelAnswer": "Registry, container image'larının saklandığı ve paylaşıldığı merkezi bir depodur; varsayılanı Docker Hub'dır, GitHub Container Registry (ghcr.io), AWS ECR ya da GitLab Container Registry gibi seçenekler de vardır. Image, adına registry adresi eklenerek etiketlenir (`ghcr.io/kullanici/app:1.4.2`), `docker login` ile giriş yapılıp `docker push` ile gönderilir, sunucuda `docker pull` ile çekilir; adda registry yazılmazsa Docker Hub varsayılır. Bu akışın faydası, image'ın CI'da bir kez build edilmesi ve test edilen aynı image'ın test ve canlı ortamlara gönderilmesidir, böylece sunucuda kaynak koddan yeniden build gerekmez. Harbor, JFrog Artifactory ya da Nexus ile kurum içi bir registry de çalıştırılabilir; internete kapalı ortamlarda image'lar yalnızca bu özel registry'den çekilir.", "keyConcepts": [ { "id": "tanim", @@ -1568,7 +1574,7 @@ "followUps": [ "Sunucunun özel bir registry'den image çekebilmesi için kimlik doğrulamayı nasıl yaparsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Docker Docs: What is a registry?, Docker overview (Docker registries), docker image tag" } ] } diff --git a/src/content/tr/content-dotnet.json b/src/content/tr/content-dotnet.json index f9f0c5d..bea1d76 100644 --- a/src/content/tr/content-dotnet.json +++ b/src/content/tr/content-dotnet.json @@ -9,7 +9,7 @@ "topic": "DI Yaşam Döngüleri", "difficulty": 2, "prompt": "ASP.NET Core'da yerleşik Dependency Injection kullanırken Transient, Scoped ve Singleton servis kayıtları arasındaki fark nedir? Entity Framework Core DbContext sınıfını kaydederken varsayılan olarak hangisi kullanılır ve neden?", - "modelAnswer": "Transient her çağrıldığında yepyeni bir nesne (instance) oluştururken, Singleton uygulamanın yaşam döngüsü boyunca ilk çağrıda tek bir nesne oluşturup tüm diğer isteklere bunu sunar. Scoped ise her HTTP isteği (request) başına bir nesne oluşturur ve o istek boyunca aynı nesneyi döndürür.\n\nSık atlanan nokta: DbContext varsayılan olarak Scoped kaydedilir. Çünkü veritabanı işlemleri genellikle tek bir HTTP isteği içinde başlar ve biter; aynı istek içindeki farklı servislerin aynı transaction'ı (ve Unit of Work modelini) paylaşabilmesi için DbContext'in Scoped olması hayati önem taşır. Singleton yapılsaydı eşzamanlı isteklerde veri çakışmaları ve thread-safety sorunları yaşanırdı.", + "modelAnswer": "Transient her istendiğinde yepyeni bir nesne oluşturur, Scoped her HTTP isteği başına bir nesne oluşturup istek boyunca aynısını verir, Singleton ise ilk istendiğinde tek bir nesne oluşturur ve uygulama kapanana kadar herkese onu verir. DbContext, AddDbContext ile varsayılan olarak Scoped kaydedilir, çünkü bir DbContext tek bir iş birimi (unit of work) için tasarlanmıştır ve web uygulamalarında her HTTP isteği genelde tek bir iş birimine denk gelir. Böylece aynı istekteki servisler aynı DbContext'i paylaşır, değişiklikler aynı change tracker'da toplanır ve tek seferde veritabanına yazılır. DbContext thread-safe değildir; Singleton yapılsaydı eşzamanlı istekler aynı örneği paralel kullanır, bu da hataya ve veri bozulmasına yol açardı.", "keyConcepts": [ { "id": "transient-new-instance", @@ -71,7 +71,7 @@ "thread-safe olma" ], "anchors": [ - "DbContext varsayılan olarak scoped'dur, böylece bir istek içindeki tüm veritabanı işlemleri aynı transaction üzerinden yürütülür.", + "DbContext varsayılan olarak scoped'dur; bir HTTP isteği tek bir iş birimine denk gelir ve o istekteki servisler aynı DbContext'i paylaşır.", "Eğer DbContext singleton olsaydı birden fazla kullanıcının eşzamanlı istekleri aynı veritabanı bağlantısı üzerinde çakışır ve thread-safety hatası alırdık." ] } @@ -80,7 +80,7 @@ "Singleton bir servisin içine Scoped bir servisi enjekte etmeye çalışırsan ne olur (Captive Dependency)?", "Arka plan görevlerinde (BackgroundService) Scoped servisleri nasıl kullanırsın?" ], - "source": "Kıdemli .NET Mülakatı, Ekim 2026" + "source": "Kendi derleme — Microsoft Learn: .NET Service lifetimes; EF Core: DbContext Lifetime, Configuration, and Initialization" }, { "id": "dotnet-iqueryable-ienumerable", @@ -89,7 +89,7 @@ "topic": "IQueryable/IEnumerable", "difficulty": 2, "prompt": "Entity Framework Core ile veritabanından veri çekerken filtreleme işlemlerinde (Where) IEnumerable ve IQueryable kullanmanın SQL sorguları ve bellek tüketimi açısından farkı nedir?", - "modelAnswer": "IQueryable, C# üzerindeki filtreleme koşullarını veritabanına gidilmeden önce bir ifade ağacında (Expression Tree) tutar ve işlemi SQL'e çevirir.\n\n```csharp\nIQueryable query = dbContext.Users.Where(u => u.Age > 18);\nvar result = query.ToList();\n```\n\nBu kod çalıştığında veritabanına doğrudan SELECT * FROM Users WHERE Age > 18 sorgusu gider, sadece ilgili satırlar ağdan çekilir.\n\nEğer tabloyu IEnumerable olarak belleğe alıp sonra filtrelerseniz:\n\n```csharp\nIEnumerable users = dbContext.Users.AsEnumerable();\nvar result = users.Where(u => u.Age > 18).ToList();\n```\n\nAyırt edici nokta: IEnumerable kullanıldığında EF Core filtrelemeyi SQL'e çevirmez. Veritabanındaki tüm tabloyu (SELECT * FROM Users) çeker ve filtrelemeyi uygulamanın belleğinde (RAM üzerinde) yapar. Tabloda milyonlarca kayıt varsa bu durum anında bellek taşmasına (Out of Memory) ve ciddi ağ yavaşlamalarına sebep olur.", + "modelAnswer": "IQueryable üzerinde yazılan Where koşulu bir ifade ağacında (expression tree) tutulur; sorgu ToList gibi bir çağrıyla çalıştırıldığında EF Core onu SQL'e çevirir, yani filtre veritabanı tarafında uygulanır ve ağdan yalnızca eşleşen satırlar gelir. AsEnumerable ile IEnumerable'a geçildikten sonra yazılan Where ise SQL'e çevrilmez; EF Core filtresiz bir sorguyla tüm tabloyu çeker ve filtreyi uygulamanın belleğinde çalıştırır. Milyonlarca kayıtlı bir tabloda her satır ağdan gelip nesneye dönüştürüldüğü için bu hem ağı hem belleği gereksiz yere yorar ve bellek taşmasına kadar gidebilir.", "keyConcepts": [ { "id": "iqueryable-sql-translation", @@ -144,7 +144,7 @@ "Veritabanından çektiğin verilerde IQueryable içinde özel bir C# metodunu (örneğin ToUpper()) çağırırsan EF Core nasıl tepki verir?", "IQueryable arayüzünü nerede IEnumerable arayüzüne dönüştürmek (AsEnumerable çağrısı) mantıklı olabilir?" ], - "source": "Kıdemli .NET Mülakatı, Ekim 2026" + "source": "Kendi derleme — Microsoft Learn: EF Core Client vs. Server Evaluation, How Queries Work" } ] } diff --git a/src/content/tr/content-java.json b/src/content/tr/content-java.json index 18da66b..8925c97 100644 --- a/src/content/tr/content-java.json +++ b/src/content/tr/content-java.json @@ -4396,10 +4396,10 @@ "label": "@Component sınıfa konur, taramayla bulunur", "aliases": [ "sınıfa", - "scan", + "component scan", + "componentscan", "tarama", "otomatik bul", - "kendi sınıf", "kendi yazdı" ], "anchors": [ @@ -5055,7 +5055,8 @@ "id": "farkli-db", "label": "Varsayılan veritabanına göre değişir", "aliases": [ - "mysql", + "mysql innodb", + "mysql'de", "innodb", "oracle", "farklı veritabanı", diff --git a/src/content/tr/content-react.json b/src/content/tr/content-react.json index 59650ce..1dfb4c7 100644 --- a/src/content/tr/content-react.json +++ b/src/content/tr/content-react.json @@ -6,10 +6,10 @@ "id": "react-props-children", "category": "react", "kind": "applied", - "topic": "props.children", + "topic": "Temeller", "difficulty": 1, "prompt": "React'te props.children nedir ve kompozisyon desenindeki rolü nedir?", - "modelAnswer": "Bir bileşenin açılış ve kapanış etiketleri arasına yazılan JSX, o bileşene children prop'u olarak geçer. Özel bir sözdizimi değil, sıradan bir prop'un JSX ile yazılmış hali.\n\n```jsx\nconst Card = ({ children }) => (\n
{children}
\n);\n\n\n

Başlık

\n

İçerik

\n
\n```\n\nBu, React'te kalıtım yerine kompozisyon kullanmayı mümkün kılan mekanizma. Card içeriğinin ne olacağını bilmeden yazılır; bilmesi de gerekmez.\n\nchildren'ın tipi sabit değildir: tek eleman, dizi, metin ya da hiçbir şey olabilir. Bu yüzden üzerinde doğrudan map çalıştırmak güvenli değildir; React.Children.map bu durumları normalize eder.", + "modelAnswer": "Bir bileşenin açılış ve kapanış etiketleri arasına yazılan JSX, o bileşene children prop'u olarak geçer; özel bir sözdizimi değil, sıradan bir prop'tur. Böylece kart ya da panel gibi kapsayıcı bileşenler içlerinde ne gösterileceğini bilmeden yazılır ve React kodu kalıtım yerine bu tür kompozisyonla yeniden kullanır. children opak bir veri yapısıdır; tek eleman, dizi, metin ya da boş olabileceği için dizi olduğu varsayılıp doğrudan map çalıştırılmaz. Dönüştürmek gerekiyorsa React.Children.map kullanılır, ama bu API nadiren gerekir ve kırılgan kod üretebilir; çoğu durumda dizi alan bir prop ya da render prop daha sağlamdır.", "keyConcepts": [ { "id": "children-is-a-prop", @@ -56,7 +56,7 @@ ], "anchors": [ "children tek eleman, dizi, metin ya da undefined olabilir; her zaman dizi değildir.", - "Doğrudan map çalıştırmak yerine React.Children.map kullanmak gerekir." + "Doğrudan map çalıştırılmaz; dönüştürmek gerekirse React.Children.map kullanılır." ] } ], @@ -64,16 +64,16 @@ "children yerine bir fonksiyon geçirilirse (render props) ne değişir?", "Sarmalayıcı bileşen children'a ekstra prop eklemek isterse ne yapar?" ], - "source": "Frontend mülakat notları" + "source": "Kendi derleme — react.dev: Passing Props to a Component (Passing JSX as children), Children; legacy.reactjs.org: Composition vs Inheritance" }, { "id": "react-virtual-dom", "category": "react", "kind": "definition", - "topic": "Virtual DOM", + "topic": "Rendering", "difficulty": 1, "prompt": "Virtual DOM nedir ve React güncelleme sırasında bunu nasıl kullanır?", - "modelAnswer": "Virtual DOM, arayüzün bellekteki hafif temsilidir: düz JavaScript nesnelerinden oluşan bir ağaç. State değiştiğinde React yeni ağacı öncekiyle karşılaştırır ve yalnızca farklı olan düğümleri gerçek DOM'a yazar.\n\nAmaç DOM işlemini hızlandırmak değil, sayısını azaltmak. Gerçek DOM'a dokunmak yeniden yerleşim ve boyama tetikler; bellekteki nesneleri karşılaştırmak ucuzdur.\n\nSık atlanan nokta: bu karşılaştırma tam bir ağaç karşılaştırması değil. Genel çözüm çok pahalı olduğu için React iki varsayımla kestirme yapar — farklı tipteki elemanlar farklı ağaç üretir, ve listelerdeki elemanların kimliği key ile belirtilir.", + "modelAnswer": "Virtual DOM, arayüzün bellekte tutulan hafif bir temsilidir, yani düz JavaScript nesnelerinden oluşan bir ağaçtır. State ya da props değiştiğinde React yeni ağacı öncekiyle karşılaştırır ve gerçek DOM'a yalnızca farklı olan düğümleri yazar; bu eşitleme sürecine reconciliation denir. Amaç DOM işlemini hızlandırmak değil sayısını azaltmaktır, çünkü gerçek DOM'a dokunmak yerleşim ve boyama hesaplarını tetikleyebilir, bellekteki nesneleri karşılaştırmak ise ucuzdur. Bu karşılaştırma tam bir ağaç karşılaştırması değildir; genel çözüm çok pahalı olduğu için React iki varsayımla kestirme yapar, farklı tipteki elemanlar farklı ağaç üretir ve listelerde kararlı kimliği key belirtir.", "keyConcepts": [ { "id": "memory-tree", @@ -127,7 +127,7 @@ "Listede index'i key olarak vermek ne zaman soruna yol açar?", "Virtual DOM olmayan bir kütüphane aynı işi nasıl yapıyor olabilir?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — legacy.reactjs.org: Virtual DOM and Internals, Reconciliation" }, { "id": "react-nedir", @@ -136,7 +136,7 @@ "difficulty": 1, "kind": "definition", "prompt": "React nedir?", - "modelAnswer": "Kullanıcı arayüzü geliştirmek için açık kaynaklı, component tabanlı bir JavaScript kütüphanesidir. Uygulamanın view katmanıyla ilgilenir; arayüz yeniden kullanılabilir component'lere bölünür ve her component kendi state'ini yönetir. Meta (Facebook) tarafından geliştirilmiştir.", + "modelAnswer": "Kullanıcı arayüzü geliştirmek için açık kaynaklı, component tabanlı bir JavaScript kütüphanesidir. Uygulamanın view katmanıyla ilgilenir; arayüz yeniden kullanılabilir component'lere bölünür ve her component kendi state'ini yönetir. İlk olarak Meta'da (Facebook) geliştirildi; bugün geliştirilmesini farklı şirket ve topluluklardan katkıcılar yürütüyor.", "keyConcepts": [ { "id": "kutuphane", @@ -196,7 +196,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org ana sayfa; react.dev: Meet the Team, Introducing the React Foundation; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "React'in kütüphane, Angular'ın framework olarak anılması proje kurarken hangi kararları sana bırakır?" + ] }, { "id": "react-ozellikleri", @@ -275,7 +278,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org ana sayfa; react.dev: Thinking in React; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Tek yönlü veri akışında bir child, parent'taki veriyi değiştirmek istediğinde ne yapılır?" + ] }, { "id": "react-jsx", @@ -330,7 +336,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Writing Markup with JSX; legacy.reactjs.org: Introducing the New JSX Transform; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "JSX içinde neden doğrudan if yazılamaz, koşullu render nasıl yapılır?" + ] }, { "id": "react-element-vs-component", @@ -399,7 +408,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: createElement; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir component'i JSX ile değil de düz fonksiyon gibi Profile() diye çağırmak neyi bozar?" + ] }, { "id": "react-state", @@ -470,12 +482,15 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: State: A Component's Memory, useState; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "State'teki bir diziyi setter yerine push ile doğrudan değiştirirsen ne olur?" + ] }, { "id": "react-props", "category": "react", - "topic": "State", + "topic": "Temeller", "difficulty": 1, "kind": "definition", "prompt": "React'te props nedir?", @@ -541,7 +556,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Passing Props to a Component; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir component'in aldığı prop'u başlangıç değeri olarak state'e kopyalaması hangi soruna yol açabilir?" + ] }, { "id": "react-state-vs-props", @@ -550,7 +568,7 @@ "difficulty": 1, "kind": "definition", "prompt": "State ile props arasındaki fark nedir?", - "modelAnswer": "State component'in kendi içinde yönettiği ve değiştirebildiği veridir; props ise parent'tan gelen ve child için salt okunur olan girdilerdir. İkisi de değiştiğinde yeniden render tetiklenir. Kısacası props fonksiyon parametrelerine, state fonksiyon içindeki değişkenlere benzer.", + "modelAnswer": "State component'in kendi içinde yönettiği ve değiştirebildiği veridir; props ise parent'tan gelen ve child için salt okunur olan girdilerdir. İkisi de değiştiğinde yeniden render tetiklenir. Kısacası props bir fonksiyona verilen parametrelere, state ise bileşenin hafızasına benzer.", "keyConcepts": [ { "id": "state-ic", @@ -610,7 +628,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Thinking in React (Props vs State); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir veri parçasının state mi, prop mu, yoksa hesaplanan bir değer mi olması gerektiğine nasıl karar verirsin?" + ] }, { "id": "react-html-vs-react-event", @@ -661,7 +682,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Responding to Events; legacy.reactjs.org: Handling Events; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "onClick={handleClick()} yazılırsa ne olur?" + ] }, { "id": "react-synthetic-event", @@ -727,7 +751,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Common components (React event object); legacy.reactjs.org: React v17.0 RC (Changes to Event Delegation); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "React 17'de olay dinleyicilerinin document yerine kök elemana bağlanması neyi çözdü?" + ] }, { "id": "react-key-prop", @@ -798,7 +825,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Rendering Lists (Keeping list items in order with key); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "key olarak Math.random() vermek neden index vermekten bile kötüdür?" + ] }, { "id": "react-shadow-dom-vs-virtual-dom", @@ -869,7 +899,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: Virtual DOM and Internals; MDN: Using shadow DOM; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir React bileşenini web component'in shadow root'u içine render ettiğinde stil ve olaylar açısından neye dikkat edersin?" + ] }, { "id": "react-controlled-component", @@ -923,7 +956,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: (Controlling an input with a state variable), Sharing State Between Components; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir input'a value verip onChange vermezsen ne olur?" + ] }, { "id": "react-uncontrolled-component", @@ -977,7 +1013,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: (Providing an initial value for an input), useRef; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir input önce value olmadan, sonra value ile render edilirse React neden uyarı verir?" + ] }, { "id": "react-fragment", @@ -1045,7 +1084,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: ; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Fragment'a key dışında className gibi başka bir prop verilebilir mi?" + ] }, { "id": "react-innerhtml", @@ -1111,7 +1153,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Common components (Dangerously setting the inner HTML); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Kullanıcı içeriğini HTML yerine Markdown olarak saklayıp render etmek XSS riskini tek başına ortadan kaldırır mı?" + ] }, { "id": "react-reconciliation", @@ -1180,7 +1225,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: Reconciliation; react.dev: Preserving and Resetting State; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Aynı yerde koşula göre input yerine textarea render edilirse kullanıcının yazdığı metne ne olur?" + ] }, { "id": "react-fiber", @@ -1247,7 +1295,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: Virtual DOM and Internals, Codebase Overview (Fiber reconciler); acdlite/react-fiber-architecture; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Render işi yarıda kesilip yeniden başlatılabiliyorsa, render sırasında yan etki çalıştırmak neden sorun olur?" + ] }, { "id": "react-lifting-state-up", @@ -1302,7 +1353,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Sharing State Between Components; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "State'i yukarı taşımak hangi durumda gereksiz render'lara yol açar, bunu nasıl sınırlarsın?" + ] }, { "id": "react-hoc", @@ -1370,7 +1424,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: Higher-Order Components; react.dev: Reusing Logic with Custom Hooks; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "HOC'ları iç içe kullanmanın dezavantajları nelerdir, custom hook bunları nasıl çözer?" + ] }, { "id": "react-portal", @@ -1437,7 +1494,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: createPortal; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Portal ile açılan bir modalda klavye odağını ve erişilebilirliği nasıl yönetirsin?" + ] }, { "id": "react-index-as-key", @@ -1509,7 +1569,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Rendering Lists; legacy.reactjs.org: Reconciliation (Keys); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Verinde kararlı bir id yoksa key'i nerede ve nasıl üretirsin?" + ] }, { "id": "react-memo", @@ -1578,7 +1641,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: memo, PureComponent; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "React.memo'ya kendi karşılaştırma fonksiyonunu vermek ne zaman mantıklıdır, riski nedir?" + ] }, { "id": "react-lazy", @@ -1587,63 +1653,82 @@ "difficulty": 2, "kind": "definition", "prompt": "React.lazy nedir?", - "modelAnswer": "Dinamik import ile bir component'i ilk render edileceği ana kadar yüklemeyi erteleyen fonksiyondur; böylece component ayrı bir bundle'a (chunk) ayrılır. Default export döndüren bir Promise bekler ve yüklenirken gösterilecek fallback için Suspense ile birlikte kullanılır. Route bazlı code splitting'in temel aracıdır.", + "modelAnswer": "Bir bileşenin kodunu dinamik import ile yükleyen bir fonksiyon alır ve bu kodu bileşen ilk kez render edilene kadar indirmez. Fonksiyon, default export'u geçerli bir bileşen olan modüle çözülen bir Promise döndürmelidir; Promise ve sonucu saklandığı için yükleme bir kez yapılır. Kod yüklenirken en yakın Suspense sınırının fallback'i gösterilir, Promise reddedilirse hata en yakın Error Boundary'ye düşer. lazy çağrısı bileşen içinde değil modülün en üst düzeyinde yapılır; bileşen içinde tanımlanırsa her render'da yeni bir bileşen tipi oluşur ve alt ağacın state'i sıfırlanır.", "keyConcepts": [ { "id": "dinamik-import", - "label": "Dinamik import", + "label": "Dinamik import'u ilk render'a kadar erteler", "aliases": [ "import(", "dinamik import", - "dynamic import" + "dynamic import", + "ilk kez render", + "render edilene kadar", + "ihtiyaç duyulduğunda" ], "anchors": [ - "React.lazy dinamik import ile çalışır." + "React.lazy bileşenin kodunu dinamik import ile, bileşen ilk kez render edilene kadar yüklemeden bekletir." ] }, { - "id": "gec-yukleme", - "label": "İhtiyaç anında yükleme", + "id": "default-export", + "label": "default export'a çözülen Promise", "aliases": [ - "tembel", - "gecikmeli", - "ihtiyaç an", - "ihtiyaç duyulduğunda", - "yüklemeyi ertele", - "sonradan yükle" + "default export", + "export default", + "varsayılan export", + "thenable", + "default olarak export" ], "anchors": [ - "Component ilk render edileceği ana kadar yüklenmez." + "Yükleme fonksiyonu, default export'u geçerli bir bileşen olan modüle çözülen bir Promise döndürmelidir." ] }, { "id": "suspense", - "label": "Suspense ile birlikte", + "label": "Yüklenirken Suspense fallback'i", "aliases": [ "suspense", "fallback" ], "anchors": [ - "Yükleme sırasında Suspense fallback'i gösterilir." + "Kod yüklenirken en yakın Suspense sınırının fallback'i gösterilir." ] }, { - "id": "code-splitting", - "label": "Code splitting", + "id": "modul-duzeyi", + "label": "Bileşen dışında, modül düzeyinde tanımlanır", "aliases": [ - "code splitting", - "code-splitting", - "chunk", - "ayrı bir bundle", - "ayrı bundle", - "ayrı dosya" + "modül düzeyinde", + "modülün en üst", + "dosyanın en üst", + "bileşen içinde tanımla", + "component içinde tanımla", + "state'i sıfırlan" + ], + "anchors": [ + "lazy bileşen içinde değil modülün en üst düzeyinde çağrılır; aksi halde her render'da yeni bir tip oluşur ve state sıfırlanır." + ] + }, + { + "id": "error-boundary", + "label": "Yükleme hatası Error Boundary'ye düşer", + "aliases": [ + "error boundary", + "hata sınırı", + "promise reddedil", + "reject", + "yüklenemezse" ], "anchors": [ - "Component ayrı bir chunk'a ayrılır." + "Promise reddedilirse React hatayı en yakın Error Boundary'ye fırlatır." ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: lazy; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Kullanıcı bir lazy sayfaya geçmeden önce o sayfanın kodunu önceden yüklemek için ne yaparsın?" + ] }, { "id": "react-hook", @@ -1706,7 +1791,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: React v16.8 (The One With Hooks); react.dev: Reusing Logic with Custom Hooks; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Hook'lar class component'teki yaşam döngüsü metotlarının birebir karşılığı mıdır?" + ] }, { "id": "react-hook-kurallari", @@ -1715,7 +1803,7 @@ "difficulty": 1, "kind": "definition", "prompt": "Hook kuralları nelerdir?", - "modelAnswer": "İki kural vardır: hook'lar yalnızca en üst seviyede çağrılır (döngü, koşul, iç içe fonksiyon veya erken return sonrasında çağrılmaz) ve yalnızca function component'lerden ya da custom hook'lardan çağrılır. Sebebi, React'in hook state'ini çağrılma sırasına göre eşleştirmesidir; sıra her render'da aynı kalmalıdır. eslint-plugin-react-hooks bu kuralları denetler.", + "modelAnswer": "Hook'lar yalnızca bileşenin en üst seviyesinde çağrılır; döngü, koşul, iç içe fonksiyon ya da try/catch içinde ve erken return'den sonra çağrılmaz. Ayrıca yalnızca React fonksiyonlarından, yani function component'lerden ya da custom hook'lardan çağrılır; normal bir JavaScript fonksiyonundan, event handler'dan ya da class component'ten çağrılmaz. Sebebi, React'in hook state'ini çağrılma sırasına göre eşleştirmesidir; sıra her render'da aynı kalmalıdır. eslint-plugin-react-hooks bu kuralların ihlallerini yakalar.", "keyConcepts": [ { "id": "ust-seviye", @@ -1774,7 +1862,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Rules of Hooks, State: A Component's Memory; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir hook'un yalnızca bir koşul sağlandığında çalışması gerekiyorsa kuralı bozmadan bunu nasıl yaparsın?" + ] }, { "id": "react-error-boundary", @@ -1843,7 +1934,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Component (Catching rendering errors with an Error Boundary); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir event handler'da oluşan hatayı error boundary'nin fallback'inde göstermek istersen ne yaparsın?" + ] }, { "id": "react-code-splitting", @@ -1852,54 +1946,38 @@ "difficulty": 2, "kind": "definition", "prompt": "Code splitting nedir?", - "modelAnswer": "Uygulama kodunu tek büyük bundle yerine, ihtiyaç anında yüklenen küçük parçalara (chunk) bölme tekniğidir. Vite veya Webpack gibi bundler'lar dinamik import() gördüğünde ayrı chunk üretir; React tarafında bu genelde React.lazy ve Suspense ile yapılır. İlk yükleme süresini kısaltır, en yaygın kullanımı route bazlı bölmedir.", + "modelAnswer": "Uygulamanın kodunu tek büyük bundle yerine ihtiyaç anında ya da paralel yüklenebilen parçalara (chunk) bölme tekniğidir; amaç ilk yüklemede indirilen kodu küçültmektir. Bundler bölme noktasını dinamik import() çağrısından anlar ve o modülü ayrı bir chunk'a koyar; en yaygın kullanım route bazlı bölmedir. Ortak bağımlılıklar da ayrı bir vendor chunk'ına alınır; uygulama kodundan daha seyrek değiştiği için çoğu zaman tarayıcı önbelleğinden gelir. Fazla bölmenin bedeli, artan istek sayısı ve bir chunk indirilip okunana kadar onun ihtiyaç duyduğu ortak chunk'ın fark edilmemesiyle oluşan istek şelalesidir. Yakında gerekecek parçalar prefetch, o anki gezinmede gerekecekler preload ile önceden istenir; Vite ortak chunk'ları dinamik import'la birlikte paralel yükleyerek bu şelaleyi kendiliğinden kaldırır.", "keyConcepts": [ { "id": "parcalama", - "label": "Kodu parçalara bölme", + "label": "Kodu ihtiyaç anında yüklenen parçalara bölme", "aliases": [ - "chunk", + "chunk'", + "chunklar", "parçalara böl", - "küçük parça", "ayrı bundle", - "bölme tekniği", - "tek büyük bundle" - ], - "anchors": [ - "Kod tek bundle yerine küçük parçalara bölünür." - ] - }, - { - "id": "ihtiyac", - "label": "İhtiyaç anında yükleme", - "aliases": [ - "ihtiyaç anında", - "gerektiğinde yüklen", - "ihtiyaç duyduğu", - "tembel yükle", - "talep üzerine", - "on demand" + "tek büyük bundle", + "ihtiyaç anında" ], "anchors": [ - "Parçalar ihtiyaç anında yüklenir." + "Kod tek bundle yerine ihtiyaç anında ya da paralel yüklenebilen parçalara (chunk) bölünür." ] }, { "id": "dinamik-import", - "label": "Dinamik import", + "label": "Bölme noktası dinamik import()", "aliases": [ "import(", "dinamik import", - "dynamic import", - "react.lazy" + "dynamic import" ], "anchors": [ - "Bölme dinamik import ve React.lazy ile yapılır." + "Bundler dinamik import() gördüğü yerde modülü ayrı bir chunk'a ayırır." ] }, { "id": "ilk-yukleme", - "label": "İlk yükleme süresi", + "label": "İlk yüklemede indirilen kodu küçültme", "aliases": [ "ilk yükleme", "initial load", @@ -1908,11 +1986,44 @@ "ilk açılış" ], "anchors": [ - "İlk yükleme süresini kısaltır." + "İlk yüklemede indirilen kod küçülür, sayfa daha hızlı açılır." + ] + }, + { + "id": "route-vendor", + "label": "Route bazlı bölme ve vendor chunk", + "aliases": [ + "route bazlı", + "route bazında", + "sayfa bazlı", + "vendor", + "ortak bağımlılık", + "splitchunks" + ], + "anchors": [ + "En yaygın bölme route bazlıdır; ortak bağımlılıklar ayrı bir vendor chunk'ına alınıp önbellekte tutulur." + ] + }, + { + "id": "sellale-prefetch", + "label": "Fazla bölmenin bedeli ve prefetch/preload", + "aliases": [ + "şelale", + "waterfall", + "prefetch", + "preload", + "istek sayısı", + "gidiş-dönüş" + ], + "anchors": [ + "Çok küçük parçalar istek sayısını ve istek şelalesini artırır; prefetch ve preload ile parçalar önceden istenir." ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — webpack: Code Splitting, Caching; Vite: Features (Async Chunk Loading Optimization); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "React'te bir bölme noktasını nasıl kurarsın ve parça yüklenirken kullanıcıya ne gösterirsin?" + ] }, { "id": "react-suspense", @@ -1981,7 +2092,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: , use; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Ekranda görünen bir içerik, alt bileşen yeniden askıya alınınca neden fallback'e dönebilir, bunu nasıl önlersin?" + ] }, { "id": "react-windowing", @@ -2049,7 +2163,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — legacy.reactjs.org: Optimizing Performance (Virtualize Long Lists); TanStack Virtual: Introduction; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Satır yükseklikleri farklı olan bir listede windowing'i zorlaştıran nedir?" + ] }, { "id": "react-useeffect", @@ -2120,7 +2237,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useEffect; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Effect içinde veri çekerken component unmount olursa ya da yanıtlar sırasız gelirse ne yaparsın?" + ] }, { "id": "react-server-components", @@ -2201,7 +2321,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Server Components, 'use client'; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Bir server component'ten client component'e fonksiyon ya da class örneği gibi her türlü prop geçirilebilir mi?" + ] }, { "id": "react-prop-drilling", @@ -2256,7 +2379,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Passing Data Deeply with Context; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Context'e geçmeden önce prop drilling'i hangi durumda sorun saymazsın?" + ] }, { "id": "react-usestate-vs-useref", @@ -2327,7 +2453,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useRef; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Render sırasında ref.current okumak ya da yazmak neden önerilmez?" + ] }, { "id": "react-useeffect-vs-uselayouteffect", @@ -2336,7 +2465,7 @@ "difficulty": 2, "kind": "definition", "prompt": "useEffect ile useLayoutEffect arasındaki fark nedir?", - "modelAnswer": "useEffect tarayıcı ekranı boyadıktan (paint) sonra asenkron çalışır; useLayoutEffect ise DOM güncellendikten sonra ama paint'ten önce senkron çalışır. Bu yüzden useLayoutEffect eleman ölçme ve konum ayarlama gibi titreme (flicker) oluşturabilecek işlerde kullanılır. Paint'i bloke ettiği için performans maliyeti vardır; varsayılan tercih useEffect olmalıdır.", + "modelAnswer": "useEffect genellikle tarayıcı ekranı boyadıktan (paint) sonra çalışır, ama tıklama gibi bir etkileşimle tetiklendiyse paint'ten önce de çalışabilir; useLayoutEffect ise DOM güncellendikten sonra, her zaman paint'ten önce senkron çalışır. Bu yüzden useLayoutEffect eleman ölçme ve konum ayarlama gibi titreme (flicker) oluşturabilecek işlerde kullanılır. Paint'i bloke ettiği için performans maliyeti vardır; varsayılan tercih useEffect olmalıdır.", "keyConcepts": [ { "id": "zamanlama", @@ -2395,7 +2524,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useLayoutEffect, useEffect; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "useLayoutEffect sunucu tarafı render'da çalışır mı, ölçüme dayanan bir arayüzde bu ne demektir?" + ] }, { "id": "react-strictmode", @@ -2463,7 +2595,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: ; legacy.reactjs.org: Strict Mode; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "StrictMode'da effect iki kez çalıştığı için bir API'ye iki istek gidiyorsa doğru düzeltme nedir?" + ] }, { "id": "react-batching", @@ -2529,7 +2664,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Queueing a Series of State Updates, React v18.0 (Automatic Batching), flushSync; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "flushSync'i sık kullanmak neden performansı düşürür?" + ] }, { "id": "react-hydration", @@ -2598,7 +2736,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: hydrateRoot; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Sunucuda ve istemcide farklı çıkan bir değeri, örneğin yerel saati, hydration hatası olmadan nasıl gösterirsin?" + ] }, { "id": "react-usereducer-vs-usestate", @@ -2668,7 +2809,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Extracting State Logic into a Reducer; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Reducer içinde API çağrısı yapmak ya da state'i doğrudan değiştirmek neden yanlıştır?" + ] }, { "id": "react-updater-function", @@ -2737,7 +2881,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useState (Updating state based on the previous state); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Updater fonksiyonu StrictMode'da neden iki kez çağrılır, bu fonksiyon için ne anlama gelir?" + ] }, { "id": "react-usememo-vs-usecallback", @@ -2806,7 +2953,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useCallback (How is useCallback related to useMemo?); soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "React Compiler kullanılan bir projede useMemo ve useCallback'e hâlâ ihtiyaç var mı?" + ] }, { "id": "react-custom-hook", @@ -2874,7 +3024,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: Reusing Logic with Custom Hooks; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "İki component aynı custom hook'u kullanırken aynı veriyi görmeleri gerekiyorsa ne yaparsın?" + ] }, { "id": "react-usetransition-vs-usedeferredvalue", @@ -2942,7 +3095,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: useTransition, useDeferredValue; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Kontrollü bir input'un kendi değerini startTransition içinde güncellemek neden işe yaramaz?" + ] }, { "id": "react-memo-context", @@ -3012,7 +3168,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — react.dev: memo (Updating a memoized component using a context), useContext; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "use(Context) ile useContext arasında context okuma açısından ne fark var?" + ] }, { "id": "react-client-vs-server-state", @@ -3061,7 +3220,7 @@ "stale", "güncel olmay", "yeniden çek", - "refetch", + "refetch'", "invalid" ], "anchors": [ @@ -3084,7 +3243,10 @@ ] } ], - "source": "sudheerj/reactjs-interview-questions (MIT)" + "source": "Kendi derleme — TanStack Query: Overview; soru kaynağı: sudheerj/reactjs-interview-questions (MIT)", + "followUps": [ + "Server state'i useState ve useEffect ile elle yönetirken en sık hangi sorunlar çıkar?" + ] } ] } diff --git a/src/content/tr/content-sql.json b/src/content/tr/content-sql.json index 1a647e8..8aefa49 100644 --- a/src/content/tr/content-sql.json +++ b/src/content/tr/content-sql.json @@ -9,7 +9,7 @@ "topic": "Index türleri", "difficulty": 2, "prompt": "PostgreSQL'de index türleri nelerdir ve hangisi hangi sorgu tipine uyar?", - "modelAnswer": "B-Tree varsayılandır ve işlerin çoğunu görür: eşitlik, aralık ve sıralama. Hash yalnızca eşitlikte çalışır, aralık ve sıralamada kullanılamaz; pratikte B-Tree eşitlikte de yeterince iyi olduğu için nadiren tercih edilir.\n\nDiğerleri veri tipine göre ayrışır. GIN, bir satırda birden çok değer barındıran alanlar içindir: dizi elemanı arama, JSONB içinde anahtar arama, tam metin arama. GiST geometrik veri ve aralık tipleri gibi 'yakınlık' sorularına cevap verir. BRIN ise fiziksel sırayla korelasyonu yüksek büyük tablolarda kullanılır — zaman damgasına göre eklenen log tablosu gibi; çok küçük yer kaplar ama sadece o korelasyon varsa işe yarar.\n\nSık atlanan nokta: index okumayı hızlandırırken yazmayı yavaşlatır. Her INSERT ve UPDATE tüm ilgili index'leri güncellemek zorundadır, bu yüzden 'her kolona index atalım' yaklaşımı yazma ağırlıklı tablolarda zarar verir.", + "modelAnswer": "PostgreSQL'de varsayılan index B-tree'dir; sıralanabilen veride eşitlik, aralık, BETWEEN, IN ve IS NULL koşullarında çalışır ve sonucu index sırasıyla da döndürebildiği için çoğu durumu karşılar. Hash index yalnızca eşitlik karşılaştırmasında kullanılabilir. GIN, dizi, JSONB ya da tam metin arama için `tsvector` gibi bir satırda birden çok değer barındıran alanlar içindir; GiST ve SP-GiST geometrik veri ve aralık tipleri gibi farklı arama stratejilerine altyapı sağlar. BRIN ardışık disk bloklarının özetini tuttuğu için çok küçük yer kaplar, ama yalnızca değerleri fiziksel sırayla güçlü ilişkili kolonlarda, örneğin zaman damgasına göre eklenen bir log tablosunda işe yarar. Her index okumayı hızlandırırken yazmayı yavaşlatır, çünkü INSERT ve UPDATE ilgili bütün index'leri güncellemek zorundadır; hiç kullanılmayan index'ler kaldırılmalıdır.", "keyConcepts": [ { "id": "btree-default", @@ -93,7 +93,7 @@ "Bileşik index'te kolon sırası neden önemli?", "Bir index'in gerçekten kullanılıp kullanılmadığını nasıl anlarsın?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: Index Types, GIN Indexes, Indexes (Introduction)" }, { "id": "sql-many-to-many-employee-project", @@ -102,7 +102,7 @@ "topic": "Veri modelleme", "difficulty": 2, "prompt": "Çalışanlar ve projeler var. Bir çalışan birden fazla projede yer alabilir, bir projede birden fazla çalışan olabilir. Tabloları yaz ve kararlarını açıkla.", - "modelAnswer": "Çok-a-çok ilişki iki tabloyla ifade edilemez; araya bir bağlantı tablosu girer.\n\n```sql\nCREATE TABLE employee (\n id BIGSERIAL PRIMARY KEY,\n full_name TEXT NOT NULL\n);\n\nCREATE TABLE project (\n id BIGSERIAL PRIMARY KEY,\n name TEXT NOT NULL\n);\n\nCREATE TABLE employee_project (\n employee_id BIGINT NOT NULL REFERENCES employee(id) ON DELETE CASCADE,\n project_id BIGINT NOT NULL REFERENCES project(id) ON DELETE CASCADE,\n role TEXT,\n assigned_at DATE NOT NULL DEFAULT CURRENT_DATE,\n PRIMARY KEY (employee_id, project_id)\n);\n\nCREATE INDEX idx_emp_proj_project ON employee_project (project_id);\n```\n\nBağlantı tablosunun birincil anahtarı iki yabancı anahtarın bileşimidir; hem aynı çalışanın aynı projeye iki kez atanmasını engeller hem ayrı bir yüzey anahtara gerek bırakmaz.\n\nRol ve atanma tarihi bağlantı tablosunda durur, çünkü bu bilgi ne çalışana ne projeye aittir.\n\nSık atlanan nokta: bileşik anahtar (employee_id, project_id) sırasıyla kurulduğu için yalnızca 'bu çalışanın projeleri' sorgusu index'ten yararlanır. Ters yön için project_id üzerine ayrı bir index gerekir.", + "modelAnswer": "Çok-a-çok ilişki iki tabloyla ifade edilemez; `employee` ve `project` tablolarının arasına, iki tarafın kimliklerini tutan `employee_project` adlı bir bağlantı tablosu girer. Bu tabloda `employee_id` ve `project_id` kendi tablolarına foreign key olarak bağlanır (silinen çalışanın ya da projenin atamaları için `ON DELETE CASCADE`), birincil anahtar da ikisinin bileşimidir; bu hem aynı çalışanın aynı projeye iki kez atanmasını engeller hem ayrı bir yapay anahtara gerek bırakmaz. Rol ve atanma tarihi gibi alanlar da bağlantı tablosunda durur, çünkü bu bilgi ne çalışana ne projeye, ikisinin ilişkisine aittir. Bileşik anahtar (employee_id, project_id) sırasıyla kurulduğu için 'bu çalışanın projeleri' sorgusu doğrudan index'ten yararlanır; ters yön için, yani bir projedeki çalışanları bulmak için project_id üzerine ayrı bir index açılır, çünkü PostgreSQL foreign key kolonuna kendiliğinden index açmaz.", "keyConcepts": [ { "id": "junction-table", @@ -173,7 +173,7 @@ "Bir çalışan aynı projeye farklı rollerle iki kez atanabilseydi şema nasıl değişirdi?", "Bağlantı tablosuna ayrı bir id kolonu koymanın artısı ve eksisi ne olurdu?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: Constraints (Primary Keys, Foreign Keys), Multicolumn Indexes" }, { "id": "sql-transaction-dirty-read", @@ -182,7 +182,7 @@ "topic": "Kirli Okuma ve İzolasyon", "difficulty": 2, "prompt": "Finansal bir sistemde 'Dirty Read' (kirli okuma) anomalisi nasıl oluşur ve varsayılan olarak bunu hangi izolasyon seviyesi engeller?", - "modelAnswer": "Dirty Read, A işlemi bir hesaba para ekleyip henüz commit etmeden önce, B işleminin bu yeni (ve belki de iptal edilecek) bakiyeyi okumasıyla oluşur. Eğer A işlemi hata alıp rollback yaparsa, B işlemi hiç var olmamış bir bakiye üzerinden işlem yapmış olur. Çoğu modern ilişkisel veritabanında (PostgreSQL, SQL Server) varsayılan izolasyon seviyesi olan 'Read Committed' bu sorunu çözer.\n\nSık atlanan nokta: Read Committed kirli okumayı engellese de, aynı işlem içinde aynı satırın iki kez okunması durumunda farklı değerler gelmesini (Non-repeatable read) engellemez; bunun için Repeatable Read veya Snapshot izolasyonu gerekir.", + "modelAnswer": "Dirty read, A işlemi bir hesaba para ekleyip henüz commit etmeden B işleminin bu yeni bakiyeyi okumasıyla oluşur; A hata alıp rollback yaparsa B hiç var olmamış bir bakiye üzerinden işlem yapmış olur. PostgreSQL ve SQL Server'da varsayılan izolasyon seviyesi olan Read Committed yalnızca commit edilmiş veriyi okuttuğu için bunu engeller; MySQL InnoDB'de varsayılan daha katı olan Repeatable Read'dir. PostgreSQL'de Read Uncommitted istense bile Read Committed gibi davrandığı için dirty read hiç oluşmaz. Read Committed ise aynı transaction içinde aynı satır iki kez okunduğunda farklı değer gelmesini (non-repeatable read) engellemez, çünkü her komut kendi başladığı andaki veriyi görür; bunun için Repeatable Read ya da Serializable gerekir.", "keyConcepts": [ { "id": "dirty-read-definition", @@ -233,7 +233,7 @@ "followUps": [ "Sadece Read Committed kullanarak, para çekme işlemi sırasında bakiyenin eksiye düşmesini (Lost Update) nasıl engellersin?" ], - "source": "Banka teknik mülakatları genel derlemesi" + "source": "Kendi derleme — PostgreSQL 18 Docs: Transaction Isolation; Microsoft Learn: SET TRANSACTION ISOLATION LEVEL (SQL Server); MySQL 8.4 Reference Manual: Transaction Isolation Levels" }, { "id": "sql-locking-lost-update", @@ -242,7 +242,7 @@ "topic": "Kilitleme stratejileri", "difficulty": 3, "prompt": "Aynı hesaptan aynı anda para çekilmeye çalışıldığında bakiyenin yanlış hesaplanmasını (Lost Update) önlemek için SELECT ... FOR UPDATE (Pessimistic) ile Versiyon kolonu (Optimistic) stratejilerini karşılaştır. Banka hesabında hangisini tercih edersin?", - "modelAnswer": "Pessimistic locking, satırı veritabanı seviyesinde kilitler:\n\n```sql\nSELECT balance FROM accounts WHERE id = 1 FOR UPDATE;\nUPDATE accounts SET balance = balance - 100 WHERE id = 1;\n```\n\nBu yöntemde ikinci işlem, ilk işlem bitip kilit açılana kadar veritabanında bekletilir (block olur).\n\nOptimistic locking ise kilit koymaz, bir `version` kolonu kullanır:\n\n```sql\nUPDATE accounts SET balance = balance - 100, version = 2 \nWHERE id = 1 AND version = 1;\n```\n\nEğer başka biri araya girip versiyonu artırdıysa, sorgu `0 rows affected` döner ve uygulamanın işlemi tekrar etmesi (retry) gerekir. Finansal hesap işlemlerinde, aynı hesaba peş peşe çok fazla istek gelme ihtimali (çakışma oranı) yüksekse Pessimistic Locking tercih edilir, çünkü Optimistic Locking sürekli retry döngülerine girip sistemi yorabilir.", + "modelAnswer": "Pessimistic yaklaşımda bakiye `SELECT balance FROM accounts WHERE id = 1 FOR UPDATE` ile okunur; bu satırı kilitler, aynı satırı güncellemek ya da kilitlemek isteyen ikinci işlem ilki commit ya da rollback yapana dek bekletilir, ardından güncelleme güncel bakiye üzerinden yapılır. Optimistic yaklaşım kilit koymaz; satırda bir version kolonu tutulur ve güncelleme `UPDATE accounts SET balance = balance - 100, version = version + 1 WHERE id = 1 AND version = 7` gibi yazılır, araya başka bir işlem girip sürümü artırdıysa sıfır satır etkilenir ve uygulama işlemi baştan tekrarlar. Aynı hesaba kısa sürede çok istek geliyorsa, yani çakışma oranı yüksekse pessimistic tercih edilir, çünkü optimistic sürekli retry döngüsüne girip sistemi yorar; çakışma seyrekse optimistic kilit tutmadığı için daha iyi ölçeklenir. PostgreSQL'in varsayılan Read Committed seviyesinde tek başına `UPDATE accounts SET balance = balance - 100 WHERE id = 1` zaten güncel satıra uygulanır; kayıp güncelleme asıl olarak bakiyeyi okuyup yeni değeri uygulamada hesaplayıp geri yazınca ortaya çıkar.", "keyConcepts": [ { "id": "pessimistic-lock-db", @@ -295,7 +295,7 @@ "followUps": [ "Pessimistic locking kullanırken Deadlock (kördüğüm) oluşmasını engellemek için birden fazla satırı güncellerken nelere dikkat etmeliyiz?" ], - "source": "Banka teknik mülakatları genel derlemesi" + "source": "Kendi derleme — PostgreSQL 18 Docs: Explicit Locking (Row-Level Locks), Transaction Isolation (Read Committed Isolation Level)" }, { "id": "sql-window-running-total", @@ -304,7 +304,7 @@ "topic": "Pencere Fonksiyonu", "difficulty": 2, "prompt": "Müşterinin 'transactions' tablosunda, tarih sırasına göre her işlem sonrası oluşan güncel bakiyesini (running total) hesaplayan sorguyu nasıl yazarsın?", - "modelAnswer": "Kümülatif toplam hesaplamak için Window (Pencere) fonksiyonlarından yararlanırız. GROUP BY kullanmadan, satır bazında toplama işlemi yapmak için SUM() fonksiyonunu OVER bloğu ile birleştiririz.\n\n```sql\nSELECT \n transaction_date, \n amount, \n SUM(amount) OVER (ORDER BY transaction_date) as running_balance\nFROM transactions\nWHERE account_id = 100;\n```\n\nOVER içindeki `ORDER BY`, SUM işleminin baştan başlayıp o anki satıra kadar olan kayıtları toplamasını sağlar.\n\nSık atlanan nokta: Eğer aynı günde birden fazla işlem varsa ve tarih kolonu saat bilgisi içermiyorsa, `ORDER BY transaction_date` aynı değerli satırları tek bir blok olarak kabul edip hepsine aynı ara toplamı basar. Bunu çözmek için `ORDER BY transaction_date, id` gibi eşsiz bir kırılım (tie-breaker) eklemek şarttır.", + "modelAnswer": "Kümülatif toplam için pencere fonksiyonu kullanılır; GROUP BY satırları tek satıra indirirken `SUM(amount) OVER (ORDER BY transaction_date)` her satırı korur ve yanına o ana kadarki toplamı yazar, örneğin `SELECT transaction_date, amount, SUM(amount) OVER (ORDER BY transaction_date) AS running_balance FROM transactions WHERE account_id = 100`. OVER içinde ORDER BY verilince varsayılan pencere bölümün başından o anki satıra kadar uzanır, bu yüzden toplam ilk işlemden o anki satıra kadar birikir. Bu varsayılan pencere RANGE modunda olduğu için ORDER BY değeri aynı olan satırları da içerir; tarih kolonunda saat yoksa aynı gündeki bütün işlemler aynı ara toplamı alır. Bunu çözmek için sıralamaya `ORDER BY transaction_date, id` gibi eşsiz bir kırılım (tie-breaker) eklenir ya da pencere `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW` ile satır bazına çevrilir.", "keyConcepts": [ { "id": "sum-over-window", @@ -357,7 +357,7 @@ "followUps": [ "Müşterilerin değil de bankanın tüm şubelerinin kümülatif hesap hareketlerini tek sorguda 'şube bazlı' ayrı ayrı göstermek istesek sorguya hangi ifadeyi eklerdik?" ], - "source": "Banka teknik mülakatları genel derlemesi" + "source": "Kendi derleme — PostgreSQL 18 Docs: Window Functions (Tutorial), Value Expressions (Window Function Calls)" }, { "id": "sql-exception", @@ -366,7 +366,7 @@ "topic": "Hata yönetimi", "difficulty": 2, "prompt": "SQL exception nedir? Veritabanında bir sorgu hata verdiğinde ne olur ve uygulama tarafında nasıl ele alınır?", - "modelAnswer": "SQL exception, veritabanının bir komutu çalıştıramadığında döndürdüğü hatadır: kısıt ihlali (unique, foreign key, not null), sözdizimi hatası, tip uyuşmazlığı, deadlock veya bağlantı kopması gibi. Her hata standart bir **SQLSTATE** koduyla gelir; örneğin `23505` unique ihlali, `40P01` deadlock'tur. Java tarafında bu hata JDBC'de `SQLException` olarak yakalanır, Spring bunu `DataAccessException` hiyerarşisine (ör. `DataIntegrityViolationException`) çevirir.\n\nTransaction içinde bir komut hata verirse o transaction bozulur; PostgreSQL'de sonraki komutlar da reddedilir ve işlem **ROLLBACK** ile geri alınmalıdır. Spring'de `@Transactional` metottan RuntimeException fırlarsa rollback otomatik yapılır.\n\nSık atlanan nokta: hatayı yakalayıp yutmak. Exception loglanmadan geçilirse veri tutarsız kalabilir; hata ya anlamlı bir iş hatasına çevrilmeli ya da yukarı fırlatılmalıdır. Deadlock ve serialization hataları ise geçicidir, bu tür hatalarda işlemi yeniden denemek (retry) doğru yaklaşımdır.", + "modelAnswer": "SQL exception, veritabanının bir komutu çalıştıramadığında döndürdüğü hatadır; kısıt ihlali (unique, foreign key, not null), sözdizimi hatası, tip uyuşmazlığı, deadlock ya da bağlantı kopması gibi. Her hata standart bir SQLSTATE koduyla gelir; PostgreSQL'de örneğin 23505 unique ihlali, 23503 foreign key ihlali, 40P01 deadlock, 40001 serialization hatasıdır. Java'da hata JDBC'de `SQLException` olarak gelir, Spring bunu `DataAccessException` hiyerarşisine çevirir; örneğin unique ve foreign key ihlalleri `DataIntegrityViolationException` ailesinden gelir. PostgreSQL'de transaction içinde bir komut hata verirse transaction bozulur, sonraki komutlar da 25P02 (in_failed_sql_transaction) ile reddedilir ve işlem ROLLBACK ile geri alınmalıdır; Spring'de `@Transactional` metottan RuntimeException fırlarsa rollback kendiliğinden yapılır. Hatayı yakalayıp yutmak veriyi tutarsız bırakabilir, hata ya anlamlı bir iş hatasına çevrilmeli ya da yukarı fırlatılmalıdır; deadlock ve serialization gibi geçici hatalarda ise işlemi yeniden denemek doğrudur.", "keyConcepts": [ { "id": "tanim", @@ -442,7 +442,7 @@ "followUps": [ "Hatayı yakalayıp logladıktan sonra transaction'a devam etmek isteseydin hangi mekanizmayı kullanırdın?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: PostgreSQL Error Codes; Spring Framework: DuplicateKeyException (Javadoc), Rolling Back a Declarative Transaction" }, { "id": "sql-slow-query-explain", @@ -451,7 +451,7 @@ "topic": "Performans", "difficulty": 2, "prompt": "Bir sorgu yavaş çalışıyor. Sebebini bulmak için hangi komutu kullanırsın ve çıktısında nelere bakarsın?", - "modelAnswer": "Sorgunun nasıl çalıştırıldığını görmek için **EXPLAIN**, gerçekten çalıştırıp ölçmek için **EXPLAIN ANALYZE** kullanılır:\n\n```sql\nEXPLAIN (ANALYZE, BUFFERS)\nSELECT * FROM transactions WHERE account_id = 100;\n```\n\nÇıktı bir **execution plan**'dır (sorgu planı). Bakılacak yerler:\n- Büyük tabloda **Seq Scan** (tüm tabloyu tarama) varsa ve az satır dönüyorsa eksik index vardır; Index Scan beklenir.\n- **Tahmini satır sayısı** (rows) ile **gerçek satır sayısı** (actual rows) çok farklıysa istatistikler eskidir, `ANALYZE` ile güncellenir.\n- En çok zamanı alan düğüm (actual time) darboğazdır; pahalı Nested Loop veya disk'e taşan Sort/Hash bunun tipik örnekleridir.\n\nSık atlanan nokta: EXPLAIN ANALYZE sorguyu gerçekten çalıştırır. UPDATE veya DELETE için kullanacaksan bir transaction içinde çalıştırıp ROLLBACK yapmalısın.", + "modelAnswer": "Sorgunun nasıl çalıştırılacağını görmek için EXPLAIN, gerçekten çalıştırıp ölçmek için EXPLAIN ANALYZE kullanılır; çıktı her düğümde maliyet ve satır tahminini gösteren bir sorgu planıdır (execution plan) ve PostgreSQL 18'den beri ANALYZE, BUFFERS bilgisini de varsayılan olarak verir. Büyük bir tabloda az satır dönen bir sorguda Seq Scan görülüyorsa, yani tablo baştan sona taranıyorsa, genelde eksik ya da kullanılamayan bir index vardır. En önemli kontrol tahmini satır sayısının (rows) gerçek satır sayısına (actual rows) yakın olup olmadığıdır; tahmin çok saparsa planlayıcı yanlış plan seçebilir ve sebeplerden biri eski istatistiktir, `ANALYZE` ile güncellenir. En çok zamanı alan düğüm darboğazdır; pahalı bir Nested Loop ya da diske taşan bir Sort veya Hash tipik örneklerdir. EXPLAIN ANALYZE sorguyu gerçekten çalıştırdığı için UPDATE ya da DELETE incelenecekse komut bir transaction içinde çalıştırılıp ardından ROLLBACK yapılır.", "keyConcepts": [ { "id": "explain", @@ -523,7 +523,7 @@ "followUps": [ "Sorgu planında index olmasına rağmen Seq Scan görüyorsan olası sebepler nelerdir?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: Using EXPLAIN; PostgreSQL 18 release notes (EXPLAIN BUFFERS)" }, { "id": "sql-find-slow-queries", @@ -532,7 +532,7 @@ "topic": "Performans", "difficulty": 2, "prompt": "Canlı sistemde hangi sorguların yavaş olduğunu, daha hiçbir sorguyu bilmeden nasıl tespit edersin?", - "modelAnswer": "Tek tek EXPLAIN çalıştırmadan önce yavaş sorguları bulmak gerekir. PostgreSQL'de iki temel araç vardır:\n\n- **pg_stat_statements** eklentisi: her sorgu kalıbının kaç kez çalıştığını, toplam ve ortalama süresini tutar. Toplam süreye göre sıralamak, sistemi en çok yoran sorguyu verir (tek seferlik yavaş sorgu değil, çok sık çalışan orta hızlı sorgu çoğu zaman asıl suçludur).\n- **log_min_duration_statement** ayarı: belirli bir sürenin (ör. 500 ms) üzerindeki sorguları loga yazar. MySQL'deki karşılığı slow query log'dur.\n\nO anda çalışan ve takılı kalan sorgular için **pg_stat_activity** görünümüne bakılır; kilit bekleyen sorgular da buradan görülür.\n\nYavaş sorgu bulunduktan sonra EXPLAIN ANALYZE ile planı incelenir.", + "modelAnswer": "PostgreSQL'de ilk araç `pg_stat_statements` eklentisidir; sunucu başlarken yüklenir ve her sorgu kalıbının kaç kez çalıştığını (`calls`), toplam ve ortalama süresini (`total_exec_time`, `mean_exec_time`) tutar. Toplam süreye göre sıralamak sistemi en çok yoran sorguyu verir; asıl yük çoğu zaman tek seferlik yavaş bir sorgudan değil, çok sık çalışan orta hızlı bir sorgudan gelir. İkinci araç `log_min_duration_statement` ayarıdır, belirlenen süreden (örneğin 500 ms) uzun süren her sorguyu süresi ve metniyle loga yazar; MySQL'deki karşılığı slow query log'dur. O anda çalışan ve takılı kalan sorgular için `pg_stat_activity` görünümüne bakılır; `wait_event_type` değeri Lock olan satırlar kilit bekleyen sorgulardır ve bulunan yavaş sorgunun planı sonra EXPLAIN ANALYZE ile incelenir.", "keyConcepts": [ { "id": "pg-stat-statements", @@ -590,7 +590,7 @@ "followUps": [ "Uygulama tarafında N+1 problemi olduğunu pg_stat_statements çıktısından nasıl anlarsın?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: pg_stat_statements, Error Reporting and Logging (log_min_duration_statement), The Cumulative Statistics System (pg_stat_activity); MySQL 8.4 Reference Manual: The Slow Query Log" }, { "id": "sql-exception-handling-db", @@ -599,7 +599,7 @@ "topic": "Hata yönetimi", "difficulty": 3, "prompt": "Veritabanı tarafında (stored procedure veya fonksiyon içinde) bir hatayı nasıl yakalar ve ele alırsın?", - "modelAnswer": "PostgreSQL'de PL/pgSQL blokları **EXCEPTION** bölümüyle hata yakalar; SQL Server'daki karşılığı **TRY...CATCH**, Oracle'da yine EXCEPTION bloğudur.\n\n```sql\nBEGIN\n INSERT INTO accounts (id, balance) VALUES (1, 0);\nEXCEPTION\n WHEN unique_violation THEN\n RAISE NOTICE 'Hesap zaten var';\nEND;\n```\n\nHata belirli bir türe göre yakalanabilir (`unique_violation`, `division_by_zero`) ya da `WHEN OTHERS` ile genel olarak. Kendi hatanı fırlatmak için **RAISE EXCEPTION** kullanılır; bu, iş kuralı ihlalini (ör. yetersiz bakiye) veritabanında durdurmanın yoludur.\n\nSık atlanan nokta: PostgreSQL'de EXCEPTION bloğu arka planda bir savepoint açar. Hata yakalandığında yalnızca o bloğun içindeki değişiklikler geri alınır, dış transaction devam eder. Bunun maliyeti vardır; döngü içinde EXCEPTION bloğu kullanmak performansı ciddi düşürür.", + "modelAnswer": "PostgreSQL'de PL/pgSQL blokları hatayı EXCEPTION bölümüyle yakalar (`BEGIN ... EXCEPTION WHEN unique_violation THEN ... END`); SQL Server'da bunun karşılığı TRY...CATCH, Oracle PL/SQL'de yine bloğun EXCEPTION bölümüdür. Hata belirli bir türe göre (`unique_violation`, `division_by_zero`) ya da `WHEN OTHERS` ile genel olarak yakalanabilir; kendi hatanı fırlatmak için `RAISE EXCEPTION` kullanılır ve yetersiz bakiye gibi bir iş kuralı ihlalini veritabanında durdurmanın yolu budur. Hata yakalandığında yalnızca o bloğun içindeki kalıcı veritabanı değişiklikleri geri alınır ve dış transaction devam eder, çünkü EXCEPTION bölümü olan blok arka planda bir alt transaction oluşturur; bu yüzden böyle bir bloğun içinde transaction bitirilemez. Bu alt transaction'ın bedeli vardır; EXCEPTION bölümü olan bir bloğa girip çıkmak belirgin biçimde pahalıdır, döngü içinde gereksiz EXCEPTION bloğu performansı düşürür.", "keyConcepts": [ { "id": "exception-blok", @@ -663,7 +663,7 @@ "followUps": [ "Uygulama tarafında birden fazla adımlı bir işlemde sadece bir adımı geri almak isteseydin SQL'de hangi komutu kullanırdın?" ], - "source": "Vakıfbank teknik mülakatı, Eylül 2026" + "source": "Kendi derleme — PostgreSQL 18 Docs: PL/pgSQL Control Structures (Trapping Errors), PL/pgSQL Transaction Management; Microsoft Learn: TRY...CATCH (Transact-SQL); Oracle Database 23ai PL/SQL Language Reference: Overview of Exception Handling" }, { "id": "sql-deadlock", @@ -672,7 +672,7 @@ "topic": "Kilitleme stratejileri", "difficulty": 3, "prompt": "Deadlock nedir, nasıl oluşur ve nasıl önlenir?", - "modelAnswer": "Deadlock, iki (veya daha fazla) transaction'ın birbirinin tuttuğu kilidi beklemesiyle oluşan kilitlenmedir. Örneğin A işlemi önce 1 numaralı hesabı, sonra 2'yi kilitlemek ister; B işlemi aynı anda önce 2'yi, sonra 1'i ister. İkisi de diğerini sonsuza kadar bekler.\n\nVeritabanı bunu **tespit eder** ve işlemlerden birini hata ile sonlandırır (PostgreSQL'de SQLSTATE `40P01`); diğeri devam eder. Uygulama, sonlandırılan işlemi yeniden denemelidir.\n\nÖnlemenin temel yolu kilitleri **her zaman aynı sırayla** almaktır: iki hesap arasında transferde önce küçük id'li hesap kilitlenir. Ayrıca transaction'ları kısa tutmak ve kilit tutarken dış servis çağrısı yapmamak riski azaltır. `lock_timeout` ile bekleme süresine sınır konabilir.", + "modelAnswer": "Deadlock, iki ya da daha fazla transaction'ın birbirinin tuttuğu kilidi beklemesiyle oluşan kilitlenmedir; A önce 1 numaralı hesabı sonra 2'yi, B aynı anda önce 2'yi sonra 1'i kilitlemek isterse ikisi de diğerini sonsuza kadar bekler. PostgreSQL bu durumu kendiliğinden tespit eder ve işlemlerden birini 40P01 (deadlock_detected) hatasıyla sonlandırıp diğerinin bitmesine izin verir; uygulama sonlandırılan işlemi yeniden denemelidir. En iyi önlem, aynı nesneler üzerindeki kilitleri bütün uygulamalarda hep aynı sırayla almaktır, örneğin iki hesap arasında transferde önce küçük id'li hesabı kilitlemek. Transaction'ları kısa tutmak ve kilit tutarken kullanıcı girdisi ya da dış servis beklememek de riski azaltır; deadlock olmayan uzun kilit beklemelerine `lock_timeout` ile sınır konabilir.", "keyConcepts": [ { "id": "karsilikli-bekleme", @@ -735,7 +735,7 @@ "followUps": [ "Deadlock ile uzun süren kilit beklemesi (lock wait) arasındaki fark nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Explicit Locking (Deadlocks), PostgreSQL Error Codes, Client Connection Defaults (lock_timeout)" }, { "id": "sql-acid", @@ -744,7 +744,7 @@ "topic": "Transaction", "difficulty": 1, "prompt": "ACID nedir? Her harfi bir banka transferi örneğiyle açıkla.", - "modelAnswer": "ACID, bir transaction'ın güvenilir olması için gereken dört özelliktir:\n\n- **Atomicity (bölünmezlik):** İşlem ya tamamen yapılır ya hiç yapılmaz. Transferde bir hesaptan para düşüp diğerine eklenmeden hata çıkarsa her şey geri alınır.\n- **Consistency (tutarlılık):** İşlem veritabanını bir geçerli durumdan başka bir geçerli duruma taşır; kısıtlar (bakiye negatif olamaz gibi) ihlal edilemez.\n- **Isolation (izolasyon):** Eşzamanlı işlemler birbirinin yarım kalmış değişikliklerini görmez; derecesi izolasyon seviyesiyle belirlenir.\n- **Durability (kalıcılık):** Commit edilen işlem, sistem çökse bile kaybolmaz; veritabanı bunu önce WAL (write-ahead log) gibi bir loga yazarak sağlar.", + "modelAnswer": "ACID, bir transaction'ın eşzamanlı çalışmada ve hata ya da elektrik kesintisi gibi durumlarda bile güvenilir kalması için gereken dört özelliktir. Atomicity'de işlem ya tamamen yapılır ya hiç yapılmaz; transferde bir hesaptan para düşülüp diğerine eklenmeden hata çıkarsa her şey geri alınır. Consistency'de veri her zaman bütünlük kısıtlarına uyar, örneğin bakiyenin negatif olamayacağını söyleyen bir CHECK kısıtı ihlal edilerek commit yapılamaz. Isolation'da eşzamanlı işlemler birbirinin commit edilmemiş değişikliklerini görmez ve bunun derecesini izolasyon seviyesi belirler; Durability'de ise commit edilen transfer sistem çökse bile kaybolmaz, PostgreSQL bunu değişikliği veri dosyalarına yazmadan önce WAL'a (write-ahead log) yazıp kalıcı depolamaya göndererek sağlar.", "keyConcepts": [ { "id": "atomicity", @@ -808,7 +808,7 @@ "followUps": [ "Durability'yi sağlamak için veritabanı commit anında diske tam olarak ne yazar?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Glossary (ACID, Atomicity, Consistency, Isolation, Durability), Write-Ahead Logging (WAL)" }, { "id": "sql-isolation-levels", @@ -817,7 +817,7 @@ "topic": "Kirli Okuma ve İzolasyon", "difficulty": 3, "prompt": "Dört izolasyon seviyesini ve her birinin hangi anomalileri engellediğini anlat.", - "modelAnswer": "SQL standardı dört seviye tanımlar; yukarı çıktıkça daha az anomali, daha fazla bekleme veya çakışma olur:\n\n- **Read Uncommitted:** Commit edilmemiş veriyi bile okur, **dirty read** mümkündür. (PostgreSQL bunu Read Committed gibi davranır.)\n- **Read Committed:** Yalnızca commit edilmiş veriyi okur, dirty read engellenir. Ama aynı satır iki kez okunduğunda farklı değer gelebilir (**non-repeatable read**). PostgreSQL ve SQL Server'da varsayılandır.\n- **Repeatable Read:** Okunan satırlar transaction boyunca değişmez görünür. Standartta yeni eklenen satırların görünmesi (**phantom read**) mümkündür; PostgreSQL snapshot kullandığı için phantom'u da engeller.\n- **Serializable:** İşlemler sırayla çalışmış gibi sonuç verir, tüm anomaliler engellenir. Bedeli, çakışmada işlemlerden birinin hata alması ve uygulamanın yeniden denemesidir.\n\nMySQL InnoDB'de varsayılan Repeatable Read'dir.", + "modelAnswer": "SQL standardı dört seviye tanımlar ve yukarı çıktıkça daha az anomali, daha fazla bekleme ya da çakışma hatası olur. Read Uncommitted commit edilmemiş veriyi bile okuyabilir, yani dirty read mümkündür; PostgreSQL bu seviyeyi Read Committed gibi uygular. Read Committed yalnızca commit edilmiş veriyi gösterir ama aynı satır iki kez okunduğunda farklı değer gelebilir (non-repeatable read); PostgreSQL, SQL Server ve Oracle'da varsayılandır, MySQL InnoDB'de ise varsayılan Repeatable Read'dir. Repeatable Read'de okunan satırlar transaction boyunca değişmez görünür; standart yeni eklenen satırların görünmesine (phantom read) izin verir ama PostgreSQL'in Repeatable Read'i phantom'u da engeller ve eşzamanlı güncellemede serialization hatası verir. Serializable işlemler sırayla çalışmış gibi sonuç verir ve bütün anomalileri engeller; PostgreSQL bunu Serializable Snapshot Isolation ile yapar, bedeli çakışmada bir işlemin 40001 hatası alması ve uygulamanın onu yeniden denemesidir.", "keyConcepts": [ { "id": "dirty", @@ -876,7 +876,7 @@ "followUps": [ "Serializable seviyesinde çalışan bir uygulama serialization failure hatası aldığında ne yapmalıdır?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Transaction Isolation; Microsoft Learn: SET TRANSACTION ISOLATION LEVEL (SQL Server); Oracle Database 23ai Concepts: Data Concurrency and Consistency; MySQL 8.4 Reference Manual: Transaction Isolation Levels" }, { "id": "sql-join-types", @@ -885,7 +885,7 @@ "topic": "Sorgu temelleri", "difficulty": 1, "prompt": "JOIN türleri nelerdir? INNER JOIN ile LEFT JOIN arasındaki farkı örnekle açıkla.", - "modelAnswer": "JOIN iki tabloyu ortak bir kolon üzerinden birleştirir:\n\n- **INNER JOIN:** Yalnızca iki tabloda da eşleşen satırları döner. Müşteri–hesap birleştirmesinde hesabı olmayan müşteri sonuçta yer almaz.\n- **LEFT JOIN:** Soldaki tablonun tüm satırlarını döner; sağda eşleşme yoksa sağın kolonları NULL gelir. Hesabı olmayan müşteri de listelenir.\n- **RIGHT JOIN:** LEFT'in tersi; pratikte tablolar yer değiştirilip LEFT JOIN yazılır.\n- **FULL OUTER JOIN:** İki taraftaki tüm satırlar, eşleşmeyenler NULL ile.\n- **CROSS JOIN:** Her satırı her satırla eşler (kartezyen çarpım).\n\nSık atlanan nokta: LEFT JOIN'den sonra WHERE'de sağ tabloya koşul yazmak (`WHERE a.status = 'ACTIVE'`) NULL satırları eler ve sorguyu fiilen INNER JOIN'e çevirir. Sağ tablo koşulu ON içine yazılmalıdır.", + "modelAnswer": "JOIN iki tabloyu bir koşul üzerinden birleştirir; INNER JOIN yalnızca iki tabloda da eşleşen satırları döner, yani hesabı olmayan müşteri sonuçta yer almaz. LEFT JOIN önce aynı eşleşmeyi yapar, sonra soldaki tablonun eşleşmeyen satırlarını da ekler; bu satırlarda sağ tablonun kolonları NULL gelir, böylece hesabı olmayan müşteri de listelenir. RIGHT JOIN bunun tersidir, FULL OUTER JOIN iki taraftaki eşleşmeyenleri de NULL'larla ekler, CROSS JOIN ise iki tablonun kartezyen çarpımını üretir. Dış birleştirmede ON içindeki koşul birleştirmeden önce, WHERE'deki koşul sonra uygulanır; LEFT JOIN'den sonra WHERE'de sağ tabloya koşul yazmak NULL satırları eler ve sorguyu fiilen INNER JOIN'e çevirir, bu yüzden sağ tablo koşulu ON içine yazılır.", "keyConcepts": [ { "id": "inner", @@ -962,7 +962,7 @@ "followUps": [ "Hiç hesabı olmayan müşterileri bulmak için hangi JOIN'i ve hangi koşulu kullanırsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Table Expressions (Joined Tables)" }, { "id": "sql-where-vs-having", @@ -971,7 +971,7 @@ "topic": "Sorgu temelleri", "difficulty": 1, "prompt": "WHERE ile HAVING arasındaki fark nedir?", - "modelAnswer": "**WHERE**, gruplama yapılmadan önce satırları filtreler; tek tek satırlara uygulanır ve aggregate fonksiyon (SUM, COUNT) içeremez. **HAVING** ise **GROUP BY** sonrası oluşan grupları filtreler ve aggregate sonuçları üzerinde koşul koyar.\n\n```sql\nSELECT account_id, SUM(amount)\nFROM transactions\nWHERE status = 'COMPLETED'\nGROUP BY account_id\nHAVING SUM(amount) > 10000;\n```\n\nÇalışma sırası: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY.\n\nSık atlanan nokta: aggregate içermeyen bir koşulu HAVING'e yazmak çalışır ama gereksiz satırların önce gruplanmasına yol açar. Satır bazlı koşullar her zaman WHERE'de olmalıdır, böylece daha az veri gruplanır.", + "modelAnswer": "WHERE gruplama yapılmadan önce tek tek satırları filtreler ve SUM ya da COUNT gibi aggregate fonksiyon içeremez; HAVING ise GROUP BY'dan sonra oluşan grupları filtreler ve koşulunu aggregate sonuçlarına koyabilir. Örneğin `WHERE status = 'COMPLETED'` yalnızca tamamlanmış işlemleri gruplamaya sokar, `HAVING SUM(amount) > 10000` de toplamı 10.000'i aşan hesapları bırakır. Mantıksal çalışma sırası FROM, WHERE, GROUP BY, HAVING, SELECT ve ORDER BY şeklindedir. Aggregate içermeyen bir koşulu HAVING'e yazmak çalışır ama gereksiz satırların önce gruplanmasına yol açar, bu yüzden satır bazlı koşullar WHERE'de durmalıdır.", "keyConcepts": [ { "id": "where-once", @@ -1034,7 +1034,7 @@ "followUps": [ "SELECT içinde verdiğin bir takma adı (alias) WHERE içinde neden kullanamazsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Table Expressions (The WHERE Clause, The GROUP BY and HAVING Clauses)" }, { "id": "sql-primary-foreign-key", @@ -1043,7 +1043,7 @@ "topic": "Veri modelleme", "difficulty": 1, "prompt": "Primary key ve foreign key nedir? Foreign key'de ON DELETE seçenekleri ne işe yarar?", - "modelAnswer": "**Primary key**, bir tablodaki her satırı benzersiz tanımlayan kolondur (veya kolonlar). Benzersiz (unique) ve NOT NULL olmak zorundadır, tabloda yalnızca bir tane olur ve veritabanı otomatik olarak üzerine index açar.\n\n**Foreign key**, bir tablodaki kolonun başka bir tablonun primary key'ine referans vermesidir. **Referans bütünlüğünü** sağlar: var olmayan bir müşteriye hesap eklenemez.\n\nReferans verilen satır silindiğinde ne olacağını ON DELETE belirler:\n- **RESTRICT / NO ACTION:** Bağlı satır varsa silmeyi engeller (varsayılan).\n- **CASCADE:** Bağlı satırları da siler.\n- **SET NULL:** Bağlı satırlardaki foreign key'i NULL yapar.\n\nSık atlanan nokta: PostgreSQL foreign key kolonuna otomatik index açmaz. Index yoksa üst tablodan silme ve JOIN'ler yavaşlar, bu yüzden foreign key kolonuna genelde elle index eklenir.", + "modelAnswer": "Primary key bir tablodaki her satırı benzersiz tanımlayan kolon ya da kolon grubudur; değerleri benzersiz ve NOT NULL olmak zorundadır, tabloda en fazla bir tane olur ve PostgreSQL üzerine otomatik olarak benzersiz bir B-tree index açar. Foreign key ise bir kolonun değerinin başka bir tablonun primary key'ine (ya da benzersiz bir kolonuna) karşılık gelmesini şart koşar ve referans bütünlüğünü sağlar, yani var olmayan bir müşteriye hesap eklenemez. Referans verilen satır silindiğinde ne olacağını ON DELETE belirler; varsayılan NO ACTION ve RESTRICT bağlı satır varsa silmeyi hata ile engeller (NO ACTION'da denetim transaction sonuna ertelenebilir, RESTRICT ertelenemez), CASCADE bağlı satırları da siler, SET NULL ve SET DEFAULT bağlı satırdaki foreign key'i NULL'a ya da kolonun DEFAULT değerine çeker. PostgreSQL foreign key kolonuna otomatik index açmaz; üst tablodan silme ve güncelleme bağlı tabloda eşleşen satırları aramak zorunda kaldığı için bu kolona genelde elle index eklenir.", "keyConcepts": [ { "id": "pk", @@ -1118,7 +1118,7 @@ "followUps": [ "Natural key yerine surrogate key (yapay id) kullanmanın avantajları nelerdir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Constraints (Primary Keys, Foreign Keys)" }, { "id": "sql-normalization", @@ -1127,7 +1127,7 @@ "topic": "Veri modelleme", "difficulty": 2, "prompt": "Normalizasyon nedir? 1NF, 2NF ve 3NF'yi kısaca açıkla.", - "modelAnswer": "Normalizasyon, veriyi tekrarı ve güncelleme anomalilerini azaltacak şekilde tablolara bölmektir. Amaç her bilginin tek bir yerde durmasıdır.\n\n- **1NF:** Her hücre tek (atomik) değer tutar; tekrar eden gruplar ve virgülle ayrılmış listeler olmaz.\n- **2NF:** 1NF'ye ek olarak, bileşik anahtarlı tablolarda her kolon anahtarın tamamına bağlıdır, bir parçasına değil (kısmi bağımlılık yok).\n- **3NF:** 2NF'ye ek olarak, anahtar olmayan kolonlar birbirine bağlı değildir (geçişli bağımlılık yok). Örneğin siparişte müşteri id'si yanında müşterinin şehrini tutmak 3NF'yi bozar; şehir müşteri tablosuna aittir.\n\nNormalize edilmemiş tabloda bir bilgiyi güncellemek birçok satırı değiştirmeyi gerektirir ve biri unutulursa veri tutarsızlaşır (update anomaly).\n\nSık atlanan nokta: aşırı normalizasyon okumada çok fazla JOIN gerektirir. Raporlama gibi okuma ağırlıklı yerlerde bilinçli **denormalizasyon** yapılabilir.", + "modelAnswer": "Normalizasyon, veriyi tekrarı ve tutarsız bağımlılıkları azaltacak şekilde tablolara bölmektir; amaç her bilginin tek bir yerde durması, böylece bir değişikliğin yalnızca bir kez yapılmasıdır. 1NF'de her hücre tek ve atomik bir değer tutar; tekrar eden gruplar (Tedarikçi1, Tedarikçi2 gibi kolonlar) ve virgülle ayrılmış listeler olmaz. 2NF'de, 1NF'ye ek olarak, bileşik anahtarlı tablolarda her kolon anahtarın tamamına bağlıdır, yalnızca bir parçasına bağlı kolon (kısmi bağımlılık) ayrı tabloya taşınır. 3NF'de anahtar olmayan kolonlar birbirine bağlı değildir (geçişli bağımlılık yoktur); siparişte müşteri id'sinin yanında müşterinin şehrini tutmak 3NF'yi bozar, çünkü şehir müşteriye aittir. Aşırı normalizasyon okumada çok fazla JOIN gerektirdiği için raporlama gibi okuma ağırlıklı yerlerde bilinçli denormalizasyon yapılabilir.", "keyConcepts": [ { "id": "amac", @@ -1205,7 +1205,7 @@ "followUps": [ "Bir bankanın raporlama veritabanında neden bilerek denormalize tablolar kullanılır?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Microsoft Learn: Database normalization description" }, { "id": "sql-composite-index-order", @@ -1214,7 +1214,7 @@ "topic": "Index türleri", "difficulty": 2, "prompt": "(account_id, created_at) üzerinde bileşik bir index var. Hangi sorgular bu index'i kullanabilir, hangileri kullanamaz?", - "modelAnswer": "Bileşik index soldan sağa sıralanmış bir yapıdır: önce account_id'ye, aynı account_id içinde created_at'e göre sıralıdır. Buna **leftmost prefix** (en soldaki kolon) kuralı denir.\n\nKullanabilenler:\n- `WHERE account_id = 5`\n- `WHERE account_id = 5 AND created_at > '2026-01-01'`\n- `WHERE account_id = 5 ORDER BY created_at` (sıralama için ek iş gerekmez)\n\nKullanamayan (verimli şekilde):\n- `WHERE created_at > '2026-01-01'` — ilk kolon koşulda yok, index'in sırası işe yaramaz.\n\nKolon sırası seçilirken kural: **eşitlik** koşulu konan kolon önce, **aralık** (>, <, BETWEEN) koşulu konan kolon sonra gelir. Aralık kolonu önde olursa, ondan sonraki kolonlar index'ten verimli yararlanamaz.", + "modelAnswer": "(account_id, created_at) index'i soldan sağa sıralıdır, yani önce account_id'ye, aynı account_id içinde de created_at'e göre dizilir; en verimli hâliyle en soldaki kolondan başlayan koşullarda kullanılır. `WHERE account_id = 5`, `WHERE account_id = 5 AND created_at > '2026-01-01'` ve `WHERE account_id = 5 ORDER BY created_at` index'ten tam yararlanır, sonuncusunda ek sıralama da gerekmez. Yalnızca created_at üzerinde koşul olan bir sorguda ilk kolon koşulda yoktur; PostgreSQL 17 ve öncesinde index bu koşulla ancak baştan sona okunarak kullanılabilir ve planlayıcı çoğu zaman tablonun tamamını okumayı seçer, PostgreSQL 18'deki skip scan ise account_id'nin farklı değer sayısı azsa her değer için ayrı arama yaparak index'i verimli kullanabilir. Kolon sırası seçilirken eşitlik koşulu konan kolon önce, aralık (`>`, `<`, `BETWEEN`) koşulu konan kolon sonra gelir; aralık kolonu önde olursa ondan sonraki kolonlar taranan index aralığını daraltamaz.", "keyConcepts": [ { "id": "soldan-saga", @@ -1232,7 +1232,7 @@ }, { "id": "ilk-kolon-yok", - "label": "İlk kolon yoksa kullanılamaz", + "label": "İlk kolon koşulda yoksa verimsiz (PG 18 skip scan istisnası)", "aliases": [ "ilk kolon", "koşulda yok", @@ -1242,7 +1242,7 @@ "yalnızca ikinci" ], "anchors": [ - "Koşulda ilk kolon yoksa index verimli kullanılamaz." + "Koşulda ilk kolon yoksa index verimli kullanılamaz; PostgreSQL 18'de ilk kolonun farklı değer sayısı azsa skip scan devreye girebilir." ] }, { @@ -1278,7 +1278,7 @@ "followUps": [ "created_at tek başına da sık sorgulanıyorsa ne yaparsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Multicolumn Indexes; PostgreSQL 18 release notes (skip scan)" }, { "id": "sql-index-not-used", @@ -1287,7 +1287,7 @@ "topic": "Index türleri", "difficulty": 3, "prompt": "Kolonda index olmasına rağmen veritabanı neden index'i kullanmayabilir? Örnekler ver.", - "modelAnswer": "Index'in var olması kullanılacağı anlamına gelmez. Tipik sebepler:\n\n- **Kolona fonksiyon uygulamak:** `WHERE LOWER(email) = 'a@b.com'` düz email index'ini kullanamaz. Çözüm ifade üzerine index açmaktır (`CREATE INDEX ON users (LOWER(email))`).\n- **Baştan joker ile LIKE:** `LIKE '%ahmet'` B-Tree kullanamaz; `LIKE 'ahmet%'` kullanabilir.\n- **Tip uyuşmazlığı:** Metin kolonunu sayıyla karşılaştırmak dönüşüm gerektirir ve index'i devre dışı bırakır.\n- **Düşük seçicilik:** Sorgu tablonun büyük kısmını döndürecekse (ör. %40'ı) optimizer tüm tabloyu taramayı daha ucuz bulur. Bu bir hata değil, doğru karardır.\n- **Eski istatistikler:** Optimizer satır sayısını yanlış tahmin ediyorsa yanlış plan seçer; ANALYZE ile güncellenir.\n\nHangisi olduğunu EXPLAIN çıktısı gösterir.", + "modelAnswer": "Kolona fonksiyon uygulamak düz index'i devre dışı bırakır; `WHERE lower(email) = 'a@b.com'` email index'ini kullanamaz, çözüm ifade üzerine index açmaktır (`CREATE INDEX ON users (lower(email))`). Baştan joker içeren `LIKE '%ahmet'` B-tree kullanamaz; `LIKE 'ahmet%'` ise PostgreSQL'de veritabanı C locale kullanıyorsa ya da index `text_pattern_ops` gibi özel bir operator class ile açılmışsa kullanabilir. Tip uyuşmazlığında dönüşüm kolon tarafında yapılırsa index kullanılamaz; MySQL'de metin kolonunu sayıyla karşılaştırmak örtük dönüşüm yüzünden index'i devre dışı bırakır, PostgreSQL ise metinle sayıyı örtük karşılaştırmaz ve hata verir. Sorgu tablonun büyük kısmını döndürecekse planlayıcı tüm tabloyu taramayı daha ucuz bulur, bu bir hata değil doğru karardır. İstatistikler eskiyse planlayıcı satır sayısını yanlış tahmin edip kötü plan seçebilir, ANALYZE istatistikleri günceller; hangi sebebin geçerli olduğunu EXPLAIN gösterir.", "keyConcepts": [ { "id": "fonksiyon", @@ -1363,7 +1363,7 @@ "followUps": [ "Büyük/küçük harf duyarsız email araması için index'i nasıl tasarlarsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Indexes on Expressions, Index Types (LIKE), Operator Classes and Operator Families; PostgreSQL 8.3 release notes (casts to text); MySQL 8.4 Reference Manual: Type Conversion in Expression Evaluation" }, { "id": "sql-covering-index", @@ -1372,7 +1372,7 @@ "topic": "Index türleri", "difficulty": 3, "prompt": "Covering index (kapsayan index) nedir ve index-only scan ne sağlar?", - "modelAnswer": "Covering index, bir sorgunun ihtiyaç duyduğu **tüm kolonları** içeren index'tir. Bu durumda veritabanı tabloya hiç gitmeden cevabı index'ten okuyabilir; buna **index-only scan** denir.\n\n```sql\nCREATE INDEX idx_tx_account ON transactions (account_id) INCLUDE (amount, created_at);\n\nSELECT amount, created_at FROM transactions WHERE account_id = 5;\n```\n\n`INCLUDE` ile eklenen kolonlar aramada kullanılmaz, yalnızca index'te taşınır. Böylece tabloya (heap) yapılan rastgele disk erişimleri ortadan kalkar ve sorgu belirgin şekilde hızlanır.\n\nSık atlanan nokta: PostgreSQL'de index-only scan, satırın görünürlüğünü kontrol etmek için **visibility map**'e bakar. Tablo sık güncelleniyor ve VACUUM geride kalıyorsa veritabanı yine tabloya gitmek zorunda kalır. Ayrıca her eklenen kolon index'i büyütür ve yazmayı yavaşlatır.", + "modelAnswer": "Covering index, bir sorgunun ihtiyaç duyduğu tüm kolonları içeren index'tir; böylece PostgreSQL tabloya (heap) hiç gitmeden cevabı index'ten okuyabilir, buna index-only scan denir. Arama anahtarı olmayan kolonlar `INCLUDE` ile eklenir; örneğin `CREATE INDEX ON transactions (account_id) INCLUDE (amount, created_at)` varken `SELECT amount, created_at FROM transactions WHERE account_id = 5` yalnızca index'ten cevaplanabilir, INCLUDE kolonları aramada kullanılmaz, yalnızca index'te taşınır. PostgreSQL'de index-only scan önce visibility map'e bakar; sayfa tümüyle görünür olarak işaretli değilse satırın görünürlüğü için yine heap'e gidilir, bu işareti VACUUM koyduğu için sık güncellenen tablolarda kazanç azalır. Her ek kolon index'i büyütür ve yazmayı yavaşlatır, geniş kolonlar eklemek index'i şişirip aramayı da yavaşlatabilir.", "keyConcepts": [ { "id": "tum-kolonlar", @@ -1433,7 +1433,7 @@ "followUps": [ "INCLUDE ile kolon eklemek ile o kolonu bileşik index'in parçası yapmak arasındaki fark nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Index-Only Scans and Covering Indexes, Routine Vacuuming (Updating the Visibility Map)" }, { "id": "sql-clustered-index", @@ -1442,7 +1442,7 @@ "topic": "Index türleri", "difficulty": 2, "prompt": "Clustered ve non-clustered index arasındaki fark nedir?", - "modelAnswer": "**Clustered index**, tablodaki satırların diskte fiziksel olarak o index'in sırasına göre saklanmasıdır; yani index ile tablo verisi aynı yapıdır. Fiziksel sıra tek olabileceği için tabloda **yalnızca bir** clustered index olur. SQL Server ve MySQL InnoDB'de primary key varsayılan olarak clustered'dır.\n\n**Non-clustered index** ayrı bir yapıdır: index değerlerini ve gerçek satırın yerini gösteren bir işaretçi tutar. Bir tabloda birden fazla olabilir; arama sonrası satıra ulaşmak için ek bir okuma gerekir.\n\nClustered index aralık sorgularında çok hızlıdır çünkü ardışık değerler diskte yan yanadır.\n\nSık atlanan nokta: PostgreSQL'de kalıcı clustered index yoktur; tüm index'ler non-clustered'dır ve tablo verisi ayrı tutulur. `CLUSTER` komutu tabloyu bir kez fiziksel olarak sıralar ama sonraki eklemelerde bu sıra korunmaz.", + "modelAnswer": "Clustered index'te tablo satırları diskte fiziksel olarak index sırasına göre saklanır, yani index ile tablo verisi aynı yapıdır; fiziksel sıra tek olabileceği için tabloda yalnızca bir clustered index bulunur. SQL Server'da primary key, başka clustered index yoksa varsayılan olarak clustered açılır, MySQL InnoDB'de ise satır verisi her zaman, genelde primary key olan clustered index'te durur. Non-clustered index ayrı bir yapıdır; anahtar değerlerini ve satırın yerini gösteren bir işaretçiyi (InnoDB'de primary key değerini) tutar, bu yüzden satıra ulaşmak için ek bir okuma gerekir ama bir tabloda birden fazla olabilir. PostgreSQL'de kalıcı clustered index yoktur, tablo verisi heap olarak ayrı tutulur ve bütün index'ler non-clustered'dır; `CLUSTER` komutu tabloyu bir kez fiziksel olarak sıralar ama sonraki eklemeler ve güncellemelerde bu sıra korunmaz.", "keyConcepts": [ { "id": "fiziksel", @@ -1506,7 +1506,7 @@ "followUps": [ "InnoDB'de primary key olarak rastgele UUID kullanmak neden yazma performansını düşürür?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: CLUSTER; Microsoft Learn: Create a Clustered Index (SQL Server); MySQL 8.4 Reference Manual: Clustered and Secondary Indexes" }, { "id": "sql-cte", @@ -1515,7 +1515,7 @@ "topic": "Sorgu temelleri", "difficulty": 2, "prompt": "CTE (WITH ifadesi) nedir? Subquery yerine ne zaman tercih edilir, recursive CTE ne işe yarar?", - "modelAnswer": "CTE (Common Table Expression), `WITH` ile tanımlanan ve sorgu boyunca bir tablo gibi kullanılan isimli geçici sonuç kümesidir.\n\n```sql\nWITH monthly AS (\n SELECT account_id, SUM(amount) AS total\n FROM transactions\n GROUP BY account_id\n)\nSELECT * FROM monthly WHERE total > 10000;\n```\n\nİç içe subquery'lere göre **okunabilirliği** artırır ve aynı ara sonuca sorguda birden fazla kez başvurmayı sağlar.\n\n**Recursive CTE** kendine başvurarak hiyerarşik veriyi dolaşır: organizasyon şeması (yönetici–çalışan), kategori ağacı veya hesap hiyerarşisi gibi.\n\nSık atlanan nokta: PostgreSQL 12 öncesinde CTE her zaman ayrı hesaplanırdı ve optimizer dışarıdaki koşulları içeri taşıyamazdı (optimization fence). 12'den itibaren tek kez kullanılan CTE'ler sorguya gömülür; eski davranış `MATERIALIZED` ile istenir.", + "modelAnswer": "CTE (Common Table Expression), `WITH` ile tanımlanan ve yalnızca o sorgu boyunca var olan isimli, geçici bir sonuç kümesidir; dış sorgu ona bir tablo gibi başvurur. İç içe subquery'lere göre okunabilirliği artırır ve aynı ara sonuca sorguda birden fazla kez başvurmayı sağlar. `WITH RECURSIVE` ile CTE kendine başvurabilir; organizasyon şeması ya da kategori ağacı gibi hiyerarşik veriyi dolaşmanın standart yolu budur. PostgreSQL 12'den önce CTE her zaman ayrı hesaplanır ve dış sorgunun koşulları içeri taşınamazdı; 12'den beri yan etkisiz, recursive olmayan ve bir kez kullanılan CTE dış sorguya gömülür, ayrı hesaplama istenirse `MATERIALIZED`, gömme zorlanacaksa `NOT MATERIALIZED` yazılır.", "keyConcepts": [ { "id": "with", @@ -1578,7 +1578,7 @@ "followUps": [ "Bir çalışanın en üst yöneticiye kadar tüm yönetici zincirini recursive CTE ile nasıl yazarsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: WITH Queries (Common Table Expressions); PostgreSQL 12 release notes" }, { "id": "sql-subquery-vs-join", @@ -1587,7 +1587,7 @@ "topic": "Sorgu temelleri", "difficulty": 2, "prompt": "Subquery ile JOIN arasındaki fark nedir? EXISTS ile IN ne zaman tercih edilir?", - "modelAnswer": "**Subquery**, başka bir sorgunun içinde çalışan sorgudur; **JOIN** ise tabloları satır bazında birleştirir. Birçok subquery JOIN olarak yeniden yazılabilir ve modern optimizer'lar bu dönüşümü çoğu zaman kendisi yapar.\n\nSubquery türleri:\n- **Bağımsız (non-correlated):** Bir kez çalışır, sonucu dış sorguya verilir.\n- **Correlated (ilişkili):** Dış sorgunun kolonuna başvurur, mantıksal olarak her satır için yeniden değerlendirilir ve yanlış yazılırsa yavaştır.\n\n**EXISTS** bir eşleşme bulduğu anda durur, yalnızca varlık sorgular. **IN** ise listeyle karşılaştırır.\n\nSık atlanan nokta: `NOT IN` alt sorgusu tek bir **NULL** değer döndürürse sonuç tamamen boş gelir, çünkü NULL ile karşılaştırma bilinmeyen (unknown) üretir. Bu yüzden \"olmayanları bul\" sorgularında `NOT EXISTS` daha güvenlidir.", + "modelAnswer": "Subquery başka bir sorgunun içinde çalışan sorgudur, JOIN ise tabloları satır bazında birleştirir; birçok subquery JOIN olarak yeniden yazılabilir. Bağımsız bir subquery bir kez çalışır, correlated (ilişkili) subquery ise dış sorgunun kolonuna başvurduğu için mantıksal olarak her satır için yeniden değerlendirilir. EXISTS yalnızca varlık sorar ve en az bir satır bulduğu anda durur; IN ise değeri alt sorgunun döndürdüğü listeyle karşılaştırır. `NOT IN` alt sorgusu tek bir NULL döndürürse koşul hiçbir satır için doğru olmaz ve sonuç boş gelir, bu yüzden 'olmayanları bul' sorgularında `NOT EXISTS` daha güvenlidir.", "keyConcepts": [ { "id": "tanim", @@ -1650,7 +1650,7 @@ "followUps": [ "Hiç işlem yapmamış hesapları bulmak için LEFT JOIN ve NOT EXISTS çözümlerini karşılaştır." ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Subquery Expressions (EXISTS, IN, NOT IN)" }, { "id": "sql-rank-functions", @@ -1659,7 +1659,7 @@ "topic": "Pencere Fonksiyonu", "difficulty": 2, "prompt": "ROW_NUMBER, RANK ve DENSE_RANK arasındaki fark nedir? Her müşterinin en büyük işlemini nasıl bulursun?", - "modelAnswer": "Üçü de pencere fonksiyonudur ve sıralamaya göre numara verir; fark eşit değerlerde ortaya çıkar. Değerler 100, 90, 90, 80 olsun:\n\n- **ROW_NUMBER:** 1, 2, 3, 4. Eşitlerde bile benzersiz numara verir.\n- **RANK:** 1, 2, 2, 4. Eşitler aynı sırayı alır, sonrasında **boşluk** bırakılır.\n- **DENSE_RANK:** 1, 2, 2, 3. Eşitler aynı sırayı alır, boşluk bırakılmaz.\n\nGrup bazında \"ilk N\" için **PARTITION BY** kullanılır:\n\n```sql\nSELECT * FROM (\n SELECT t.*, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY amount DESC) AS rn\n FROM transactions t\n) x\nWHERE rn = 1;\n```\n\nPencere fonksiyonu WHERE'de doğrudan kullanılamaz, çünkü WHERE pencere fonksiyonlarından önce çalışır; bu yüzden sorgu dış bir katmana (subquery veya CTE) alınır.", + "modelAnswer": "Üçü de pencere fonksiyonudur ve ORDER BY'a göre numara verir, fark eşit değerlerde ortaya çıkar; değerler 100, 90, 90, 80 olsun. ROW_NUMBER eşitlerde bile benzersiz numara verir (1, 2, 3, 4), RANK eşitlere aynı sırayı verip sonrasında boşluk bırakır (1, 2, 2, 4), DENSE_RANK ise eşitlere aynı sırayı verir ama boşluk bırakmaz (1, 2, 2, 3). Her müşterinin en büyük işlemi için `ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY amount DESC)` ile müşteri bazında numara verilir ve numarası 1 olan satırlar alınır. Pencere fonksiyonları yalnızca SELECT listesinde ve ORDER BY'da kullanılabilir, WHERE'den sonra mantıksal olarak çalıştıkları için WHERE'de kullanılamaz; bu yüzden numaralandırma bir alt sorguya ya da CTE'ye alınır ve filtre dış katmanda `WHERE rn = 1` olarak yazılır.", "keyConcepts": [ { "id": "row-number", @@ -1739,7 +1739,7 @@ "followUps": [ "Her şubenin en yüksek bakiyeli 3 müşterisini, eşitlik durumunda hepsini gösterecek şekilde nasıl listelersin?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Window Functions (functions-window), Window Functions (Tutorial)" }, { "id": "sql-delete-truncate-drop", @@ -1748,7 +1748,7 @@ "topic": "Sorgu temelleri", "difficulty": 1, "prompt": "DELETE, TRUNCATE ve DROP arasındaki fark nedir?", - "modelAnswer": "- **DELETE:** Satırları siler, **WHERE** ile koşul alabilir. Satır satır çalışır, trigger'ları tetikler ve transaction içinde geri alınabilir. Büyük tablolarda yavaştır.\n- **TRUNCATE:** Tablodaki **tüm satırları** tek seferde siler, WHERE almaz. Satır satır işlem yapmadığı için çok hızlıdır; satır bazlı trigger'ları tetiklemez.\n- **DROP:** Tablonun kendisini, yapısıyla (kolonlar, index'ler, kısıtlar) birlikte tamamen kaldırır.\n\nDELETE bir DML, TRUNCATE ve DROP ise DDL komutudur.\n\nSık atlanan nokta: \"TRUNCATE geri alınamaz\" bilgisi her veritabanı için doğru değildir. PostgreSQL'de TRUNCATE transaction içinde ROLLBACK ile geri alınabilir; Oracle ve MySQL'de ise örtük commit yapar. Ayrıca başka tablonun foreign key ile referans verdiği bir tablo, CASCADE belirtilmeden TRUNCATE edilemez.", + "modelAnswer": "DELETE satırları WHERE ile koşullu silebilir, satır satır çalışır, DELETE trigger'larını tetikler ve büyük tablolarda yavaştır. TRUNCATE ise WHERE almaz, tablodaki tüm satırları dolaşmadan tek seferde siler ve diski hemen geri verir; PostgreSQL'de ON DELETE trigger'larını değil yalnızca ON TRUNCATE trigger'larını tetikler. DROP tablonun kendisini kolonları, index'leri ve kısıtlarıyla birlikte tamamen kaldırır; DELETE bir DML komutudur, TRUNCATE ve DROP ise DDL sayılır. 'TRUNCATE geri alınamaz' bilgisi her veritabanı için doğru değildir; PostgreSQL'de TRUNCATE transaction içinde ROLLBACK ile geri alınabilir, MySQL'de ise örtük commit yapar, Oracle'da da geri alınamaz. PostgreSQL başka tabloların foreign key ile referans verdiği bir tabloyu, o tablolar da aynı komuta eklenmedikçe ya da CASCADE yazılmadıkça TRUNCATE etmez.", "keyConcepts": [ { "id": "delete", @@ -1813,7 +1813,7 @@ "followUps": [ "Milyonlarca satırlık bir tablodan eski kayıtları silmen gerekiyor; tek bir DELETE çalıştırmak neden risklidir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: TRUNCATE; MySQL 8.4 Reference Manual: Statements That Cause an Implicit Commit; Oracle Database 23ai SQL Language Reference: TRUNCATE TABLE" }, { "id": "sql-union-vs-union-all", @@ -1822,7 +1822,7 @@ "topic": "Sorgu temelleri", "difficulty": 1, "prompt": "UNION ile UNION ALL arasındaki fark nedir?", - "modelAnswer": "İkisi de iki sorgunun sonucunu alt alta birleştirir. **UNION** sonuçtaki **tekrar eden satırları kaldırır**; **UNION ALL** tüm satırları olduğu gibi döner.\n\nUNION, tekrarları bulmak için sonucu sıralar veya hash'ler; bu ek bir maliyettir. Bu yüzden tekrar olmayacağı biliniyorsa ya da tekrarlar isteniyorsa **UNION ALL daha hızlıdır** ve tercih edilmelidir.\n\nHer iki sorgunun **kolon sayısı ve tipleri uyumlu** olmalıdır; sonuç kolon isimleri ilk sorgudan alınır.\n\nSık atlanan nokta: \"emin olmak için\" alışkanlıkla UNION yazmak büyük veri setlerinde gereksiz sıralamaya yol açar. Örneğin farklı yıllara ait arşiv tablolarını birleştirirken satırlar zaten çakışmayacağı için UNION ALL doğru seçimdir.", + "modelAnswer": "İkisi de iki sorgunun sonucunu alt alta birleştirir; UNION sonuçtaki tekrar eden satırları DISTINCT gibi kaldırır, UNION ALL ise tüm satırları olduğu gibi döner. Tekrarları bulmak için veritabanı sonucu sıralar ya da hash'ler, bu ek bir maliyettir; bu yüzden tekrar olmayacağı biliniyorsa ya da tekrarlar isteniyorsa UNION ALL daha hızlıdır. İki sorgu birleşime uygun olmalıdır, yani aynı sayıda kolon döndürmeli ve karşılıklı kolonların tipleri uyumlu olmalıdır. Farklı yıllara ait arşiv tablolarını birleştirmek gibi satırların zaten çakışmadığı durumlarda alışkanlıkla UNION yazmak büyük veride gereksiz bir sıralama demektir.", "keyConcepts": [ { "id": "tekrar", @@ -1887,7 +1887,7 @@ "followUps": [ "UNION ile INTERSECT ve EXCEPT arasındaki fark nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Combining Queries (UNION, INTERSECT, EXCEPT)" }, { "id": "sql-null-handling", @@ -1896,7 +1896,7 @@ "topic": "Sorgu temelleri", "difficulty": 2, "prompt": "SQL'de NULL nasıl davranır? NULL = NULL neden doğru dönmez?", - "modelAnswer": "NULL bir değer değil, **bilinmeyen** veya eksik değer anlamına gelir. Bu yüzden NULL ile yapılan her karşılaştırma TRUE ya da FALSE değil **UNKNOWN** döner; `NULL = NULL` bile doğru değildir. SQL bu üç değerli mantıkla çalışır.\n\n- NULL kontrolü `= NULL` ile değil **IS NULL / IS NOT NULL** ile yapılır.\n- **COALESCE** ilk NULL olmayan değeri döner: `COALESCE(phone, 'yok')`.\n- Aggregate fonksiyonlar NULL'ları **yok sayar**: `COUNT(phone)` NULL olmayanları sayar, `COUNT(*)` tüm satırları. `AVG` da yalnızca dolu değerlerin ortalamasını alır.\n- `WHERE status <> 'CLOSED'` koşulu status'u NULL olan satırları da dışarıda bırakır.\n\nSık atlanan nokta: NULL ile yapılan aritmetik işlemin sonucu da NULL'dır. `balance + bonus` ifadesinde bonus NULL ise sonuç NULL olur; bunu önlemek için `balance + COALESCE(bonus, 0)` yazılır.", + "modelAnswer": "NULL bir değer değil, bilinmeyen ya da eksik değer anlamına gelir; bu yüzden NULL ile yapılan sıradan karşılaştırma TRUE ya da FALSE değil UNKNOWN (null) üretir ve iki bilinmeyenin eşit olup olmadığı bilinmediği için `NULL = NULL` bile doğru dönmez. Kontrol `= NULL` ile değil `IS NULL` ya da `IS NOT NULL` ile yapılır; iki NULL'u eşit saymak gerekirse PostgreSQL'de `IS NOT DISTINCT FROM` kullanılır. Aggregate fonksiyonlar NULL girdileri yok sayar, `COUNT(*)` bütün satırları, `COUNT(phone)` yalnızca NULL olmayanları sayar, satır yoksa `SUM` sıfır değil NULL döner. NULL ile yapılan aritmetiğin sonucu da NULL'dır, bu yüzden `balance + bonus` yerine `balance + COALESCE(bonus, 0)` yazılır; `WHERE status <> 'CLOSED'` da status'u NULL olan satırları dışarıda bırakır.", "keyConcepts": [ { "id": "bilinmeyen", @@ -1967,7 +1967,7 @@ "followUps": [ "Bir kolonun UNIQUE kısıtı varken iki satırda NULL değer olabilir mi? Neden?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Comparison Functions and Operators, Aggregate Functions, Conditional Expressions (COALESCE)" }, { "id": "sql-n-plus-one", @@ -1976,7 +1976,7 @@ "topic": "Performans", "difficulty": 2, "prompt": "N+1 sorgu problemi nedir, nasıl fark edilir ve nasıl çözülür?", - "modelAnswer": "N+1 problemi, bir liste için **1 sorgu** atıldıktan sonra listedeki **her eleman için ayrı bir sorgu** daha atılmasıdır. 100 müşteri listelenip her müşterinin hesapları ayrı ayrı çekilirse toplamda 101 sorgu çalışır. Her biri hızlı olsa da toplam ağ gidiş-dönüşü sistemi yavaşlatır.\n\nGenelde ORM'lerdeki **lazy loading** yüzünden fark edilmeden oluşur: JPA'da `@OneToMany` ilişkiye döngü içinde erişmek her seferinde yeni sorgu tetikler.\n\nFark etmenin yolu SQL loglarını açmak (`spring.jpa.show-sql`) veya Hibernate statistics ile tek bir istekte çalışan sorgu sayısına bakmaktır.\n\nÇözümler:\n- **JOIN FETCH** veya `@EntityGraph` ile ilişkiyi tek sorguda çekmek.\n- `@BatchSize` ile ilişkileri tek tek değil, `IN (...)` ile toplu yüklemek.\n- Yalnızca gereken alanlar için DTO projection kullanmak.\n\nSık atlanan nokta: koleksiyonlarda JOIN FETCH ile sayfalama birlikte kullanılırsa Hibernate sayfalamayı bellekte yapar; bu durumda batch fetching daha uygundur.", + "modelAnswer": "N+1 problemi, bir liste için 1 sorgu atıldıktan sonra listedeki her eleman için ayrı bir sorgu daha atılmasıdır; 100 müşteri listelenip her birinin hesapları ayrı ayrı çekilirse 101 sorgu çalışır ve her biri hızlı olsa da toplam gidiş-dönüş sistemi yavaşlatır. JPA'da genelde lazy loading yüzünden fark edilmeden oluşur, örneğin `@OneToMany` bir ilişkiye döngü içinde erişmek her seferinde yeni bir sorgu tetikler; aynı sorun elle yazılmış JDBC kodunda da görülür. Fark etmenin yolu SQL loglarını açmak (`spring.jpa.show-sql`) ya da Hibernate statistics ile tek bir istekte çalışan sorgu sayısına bakmaktır. Çözüm ilişkiyi `JOIN FETCH` ya da `@EntityGraph` ile tek sorguda çekmek, `@BatchSize` ile ilişkileri birincil anahtar grupları hâlinde toplu yüklemek ya da yalnızca gereken alanlar için DTO projection kullanmaktır. Koleksiyon `JOIN FETCH` ile sayfalama birleştirilirse Hibernate bütün eşleşen sonuçları çekip sınırı bellekte uygular, bu durumda batch fetching daha uygundur.", "keyConcepts": [ { "id": "tanim", @@ -2051,7 +2051,7 @@ "followUps": [ "JOIN FETCH ile iki farklı koleksiyonu aynı anda çekmeye çalışırsan ne olur?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — Hibernate ORM 7.0: Introduction (Association fetching, Batch fetching), User Guide (pagination with fetch join)" }, { "id": "sql-injection", @@ -2134,7 +2134,7 @@ "topic": "Veritabanı nesneleri", "difficulty": 2, "prompt": "View ile materialized view arasındaki fark nedir? Hangisi ne zaman kullanılır?", - "modelAnswer": "**View**, kaydedilmiş bir sorgudur; veri tutmaz. Her sorgulandığında arkasındaki SQL **yeniden çalışır**, dolayısıyla her zaman güncel veriyi gösterir. Karmaşık JOIN'leri gizlemek ve kullanıcılara tablonun yalnızca belirli kolonlarını göstermek (güvenlik) için kullanılır.\n\n**Materialized view** sorgunun sonucunu **diskte saklar**. Sorgulandığında hesaplama yapılmaz, bu yüzden pahalı raporlarda çok hızlıdır. Bedeli, verinin **eski (stale)** olabilmesidir; güncel hâli için **REFRESH** çalıştırılması gerekir:\n\n```sql\nREFRESH MATERIALIZED VIEW CONCURRENTLY daily_summary;\n```\n\n`CONCURRENTLY` yenileme sırasında okumaları engellemez ama view üzerinde unique index ister.\n\nSeçim: veri sürekli güncel olmalıysa view; ağır, sık okunan ve birkaç dakika/saat gecikmeyi tolere eden raporlar için materialized view.", + "modelAnswer": "View kaydedilmiş bir sorgudur ve veri tutmaz; PostgreSQL'de view fiziksel olarak saklanmaz, her başvurulduğunda arkasındaki sorgu yeniden çalışır, dolayısıyla her zaman güncel veriyi gösterir. Karmaşık JOIN'leri gizlemek ya da kullanıcıya tablonun yalnızca bazı kolonlarını açmak için kullanılır. Materialized view ise sorgunun sonucunu diskte saklar, sorgulandığında hesaplama yapılmadığı için pahalı raporlarda çok hızlıdır; bedeli verinin son yenilemeden beri eskiyebilmesidir ve `REFRESH MATERIALIZED VIEW` ile içerik baştan oluşturulur. `CONCURRENTLY` seçeneği yenileme sırasında okumaları engellemez ama materialized view üzerinde yalnızca kolon adlarından oluşan, koşulsuz bir unique index ister. Veri sürekli güncel olmalıysa view, ağır, sık okunan ve birkaç dakikalık ya da saatlik gecikmeyi tolere eden raporlar için materialized view seçilir.", "keyConcepts": [ { "id": "view", @@ -2198,7 +2198,7 @@ "followUps": [ "Bir view üzerinden INSERT veya UPDATE yapılabilir mi?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: CREATE VIEW, REFRESH MATERIALIZED VIEW" }, { "id": "sql-procedure-vs-function", @@ -2207,7 +2207,7 @@ "topic": "Veritabanı nesneleri", "difficulty": 2, "prompt": "Stored procedure ile function arasındaki fark nedir? İş mantığını veritabanına koymanın artıları ve eksileri neler?", - "modelAnswer": "**Function** bir değer (veya tablo) **döndürür** ve SELECT içinde kullanılabilir: `SELECT calculate_interest(balance) FROM accounts`. **Stored procedure** ise `CALL` ile çağrılır, bir işlem dizisini çalıştırır ve SELECT içinde kullanılamaz. PostgreSQL'de procedure'lerin farkı içeride **COMMIT/ROLLBACK** ile transaction kontrolü yapabilmeleridir; function'lar çağıranın transaction'ı içinde çalışır.\n\nİş mantığını veritabanına koymanın artıları: veri yanında çalıştığı için ağ trafiği azalır, birden fazla uygulama aynı kuralı paylaşır.\n\nEksileri: **test etmesi ve versiyonlaması** zordur, hata ayıklama araçları sınırlıdır, mantık uygulama ve veritabanı arasında bölünür ve belirli bir veritabanına **bağımlılık** (vendor lock-in) oluşur.\n\nBankalarda yoğun kullanılmasının sebebi genelde eski sistemler ve toplu (batch) işlemlerde veri yanında çalışmanın sağladığı performanstır.", + "modelAnswer": "PostgreSQL'de function bir değer ya da tablo döndürür ve bir sorgunun içinde çağrılır, örneğin `SELECT calculate_interest(balance) FROM accounts`; procedure ise değer döndürmez (gerekirse OUT parametreleriyle veri verir), CALL ile tek başına çağrılır ve SELECT içinde kullanılamaz. Procedure, çağıran CALL açık bir transaction bloğunun içinde değilse çalışırken COMMIT ya da ROLLBACK yapabilir; function bunu yapamaz ve çağıranın transaction'ı içinde çalışır. İş mantığını veritabanına koymanın artısı, kodun veri yanında çalışıp ağ trafiğini azaltması ve birden fazla uygulamanın aynı kuralı paylaşmasıdır. Eksisi, test etmenin ve versiyonlamanın zorlaşması, hata ayıklama araçlarının sınırlı kalması, mantığın uygulama ile veritabanı arasında bölünmesi ve belirli bir veritabanına bağımlılık (vendor lock-in) oluşmasıdır.", "keyConcepts": [ { "id": "function-deger", @@ -2282,7 +2282,7 @@ "followUps": [ "Uygulamada mı yoksa stored procedure'de mi faiz hesaplaması yapardın? Neden?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: User-Defined Procedures, PL/pgSQL Transaction Management" }, { "id": "sql-trigger", @@ -2291,7 +2291,7 @@ "topic": "Veritabanı nesneleri", "difficulty": 2, "prompt": "Trigger nedir, ne için kullanılır ve riskleri nelerdir?", - "modelAnswer": "Trigger, bir tabloda **INSERT, UPDATE veya DELETE** gerçekleştiğinde **otomatik olarak çalışan** fonksiyondur. İşlemden önce (**BEFORE**) veya sonra (**AFTER**), her satır için ya da komut başına bir kez çalışabilir.\n\nTipik kullanımlar:\n- **Audit log:** Hesap bakiyesi değiştiğinde eski ve yeni değeri bir log tablosuna yazmak.\n- `updated_at` kolonunu otomatik güncellemek.\n- Uygulama kodunu atlayan değişikliklerde bile bir kuralı zorlamak.\n\nRiskleri:\n- **Gizli davranış:** Kodu okuyan kişi bir UPDATE'in arka planda başka tablolara yazdığını görmez; hata ayıklama zorlaşır.\n- **Performans:** Her satırda çalıştığı için toplu işlemleri ciddi yavaşlatabilir.\n- **Zincirleme:** Bir trigger'ın başka bir trigger'ı tetiklemesi öngörülemeyen sonuçlar doğurur.\n\nBu yüzden trigger'lar dar ve iyi belgelenmiş işler için kullanılmalı, iş mantığının ana yeri olmamalıdır.", + "modelAnswer": "Trigger, bir tabloda INSERT, UPDATE, DELETE ya da TRUNCATE gerçekleştiğinde veritabanının otomatik olarak çalıştırdığı bir fonksiyondur; işlemden önce (BEFORE), sonra (AFTER) ya da view'larda işlemin yerine (INSTEAD OF), her satır için ya da komut başına bir kez çalışabilir. Tipik kullanımlar, hesap bakiyesi değiştiğinde eski ve yeni değeri bir audit log tablosuna yazmak, `updated_at` kolonunu güncellemek ve uygulama kodunu atlayan değişikliklerde bile bir kuralı zorlamaktır. Riski gizli davranıştır; kodu okuyan kişi bir UPDATE'in arka planda başka tablolara yazdığını görmez ve hata ayıklama zorlaşır, satır başına çalışan trigger'lar da toplu işlemleri ciddi yavaşlatabilir. Bir trigger'ın çalıştırdığı SQL başka trigger'ları da tetikleyebilir; PostgreSQL bu zincirleme tetiklemeye derinlik sınırı koymaz, sonsuz döngüyü önlemek trigger'ı yazanın sorumluluğundadır, bu yüzden trigger'lar dar ve iyi belgelenmiş işler için kullanılmalıdır.", "keyConcepts": [ { "id": "otomatik", @@ -2354,7 +2354,7 @@ "followUps": [ "Audit log'u trigger yerine uygulama katmanında tutmanın avantajı ve dezavantajı nedir?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: Overview of Trigger Behavior" }, { "id": "sql-pagination", @@ -2363,7 +2363,7 @@ "topic": "Performans", "difficulty": 3, "prompt": "Büyük bir tabloda sayfalama yaparken OFFSET kullanmanın sorunu nedir? Alternatifi nedir?", - "modelAnswer": "`LIMIT 20 OFFSET 100000` sorgusunda veritabanı ilk 100.000 satırı **okuyup atar**, sonra 20 tanesini döner. Sayfa ilerledikçe sorgu **yavaşlar**.\n\nİkinci sorun **tutarsızlıktır**: kullanıcı sayfalar arasında gezinirken araya yeni kayıt eklenirse satırlar kayar; aynı kayıt iki sayfada görünebilir veya bir kayıt hiç görünmeyebilir.\n\nAlternatif **keyset (cursor) pagination**'dır. Son görülen kaydın değeri hatırlanır ve bir sonraki sayfa ondan başlatılır:\n\n```sql\nSELECT * FROM transactions\nWHERE (created_at, id) < (:lastCreatedAt, :lastId)\nORDER BY created_at DESC, id DESC\nLIMIT 20;\n```\n\nIndex'li kolon üzerinden doğrudan konuma atladığı için **her sayfa aynı hızdadır**. Sıralamaya `id` eklenmesi, aynı zaman damgasına sahip kayıtlarda sıranın kesin olmasını sağlar.\n\nDezavantajı: \"47. sayfaya git\" gibi rastgele bir sayfaya atlanamaz; yalnızca önceki/sonraki gezinmesi yapılır. Bu yüzden sonsuz kaydırma ve hesap hareketleri listesi için uygundur.", + "modelAnswer": "`LIMIT 20 OFFSET 100000` sorgusunda PostgreSQL atlanan 100.000 satırı yine de üretip okur ve atar, sonra 20 tanesini döner; bu yüzden sayfa ilerledikçe sorgu yavaşlar. İkinci sorun tutarsızlıktır; kullanıcı sayfalar arasında gezinirken araya yeni kayıt eklenirse satırlar kayar, aynı kayıt iki sayfada görünebilir ya da bir kayıt hiç görünmeyebilir, sıralama benzersiz bir anahtarla yapılmıyorsa sonuç zaten belirsizdir. Alternatif keyset (cursor) pagination'dır; son görülen kaydın değerleri hatırlanır ve sonraki sayfa `WHERE (created_at, id) < (:lastCreatedAt, :lastId) ORDER BY created_at DESC, id DESC LIMIT 20` gibi bir koşulla ondan başlatılır. Bu sorgu index'li kolon üzerinden doğrudan konuma atladığı için her sayfa aynı hızda gelir, sıralamaya eklenen `id` de aynı zaman damgalı kayıtlarda sırayı kesinleştirir. Bedeli, rastgele bir sayfaya atlanamaması ve yalnızca önceki/sonraki gezinmenin yapılabilmesidir, bu yüzden sonsuz kaydırma ve hesap hareketleri listesi için uygundur.", "keyConcepts": [ { "id": "offset-yavas", @@ -2441,7 +2441,7 @@ "followUps": [ "Keyset pagination'da geri (önceki sayfa) gitmeyi nasıl uygularsın?" ], - "source": "Kendi derleme" + "source": "Kendi derleme — PostgreSQL 18 Docs: LIMIT and OFFSET, Row and Array Comparisons (Row Constructor Comparison)" } ] }