Mülakata hazırlık ve sonrası

Kursun son dersine geldin. Öğrendiklerini bu kez bir yabancıya, kısa sürede ve biraz heyecanla göstermeyi çalışacaksın: mülakat. Önce bir işe alım sürecinin aşamalarını tanıyacaksın. Sonra junior mülakatlarında en sık gelen JavaScript, React ve SQL sorularını kısa ve doğru cevaplarıyla, her birini çalışan bir örnekle geçeceksin. Ardından canlı kodlamada sesli düşünmeyi, bir projeni anlatmayı, bilmediğin soruya cevap vermeyi ve ev ödevi teslim etmeyi öğreneceksin. En sonda işe girdikten sonraki ilk üç ay ve öğrenmeye nasıl devam edeceğin var.

Bu dersin amacı cevap ezberletmek değil. Mülakatçı, ezberlenmiş bir tanımı ilk ek soruda fark eder. Buradaki her cevabı bir kez kendin çalıştırıp kendi sözlerinle söyleyebildiğinde hazırsın.

#Mülakat iki yönlü bir görüşmedir

Bir junior ilanına başvuran adaydan her şeyi bilmesi beklenmez. Mülakatçı üç şeyi anlamaya çalışır: Temelleri sağlam mı? Takılınca ne yapıyor? Onunla birlikte çalışmak nasıl olur? Bu üçünün hiçbiri "bütün soruları doğru bildi" ile ölçülmez. Bir soruyu bilmeyip nasıl bulacağını açıkça anlatan aday, ezberini okuyup ilk ek soruda susan adaydan çoğu zaman daha iyi izlenim bırakır.

Görüşme senin için de bir sınavdır: o ekipte öğrenebilecek misin, sana kim yardım edecek, iş tarifi ilandakiyle aynı mı? Bunları sormak saygısızlık değil, ciddiyet işaretidir. Sorulacak sorular kültür görüşmesi bölümünde.

#Mülakat aşamaları

Şirketten şirkete değişse de bir junior işe alım süreci çoğunlukla şu sırayla ilerler:

Süreler ve sıra yalnızca fikir versin diye var. Bazı şirketler canlı kodlamanın yerine otomatik puanlanan bir çevrim içi test gönderir, bazıları teknik görüşmeyle canlı kodlamayı aynı saate sığdırır. Sürecin nasıl ilerleyeceğini ön görüşmede sormak en kolay yoldur: "Süreçte sırada hangi adımlar var?"

#Ön görüşme

İlk konuşma genelde işe alım uzmanıyladır ve tekniğe pek girmez. Amaç senin ilana uyup uymadığını, beklentilerinizin örtüşüp örtüşmediğini görmektir.

Sık gelen sorular: "Kendinden bahseder misin?", "Neden yazılım?", "Neden bizim şirketimiz?", "Maaş beklentin nedir?", "Ne zaman başlayabilirsin?". İlkine 30–45 saniyelik, önceden çalışılmış bir cevap hazırla. Köşeli parantezli yerleri kendi bilgilerinle doldur:

Ben [adın]. [Süre] boyunca kendikendime yazılım öğrendim; TypeScript,React, Node.js ve PostgreSQL ile tamyığın projeler yaptım. En sevdiğimproje [proje]: [bir cümlede neyaptığı]. Şu an ilk junior işimiarıyorum. Sizin ilanınızda [ilandakisomut bir şey] dikkatimi çekti, çünkü[kısa sebep].

Maaş sorusuna hazırlıksız yakalanma: benzer ilanlara ve kaynağı ile tarihi belli güncel maaş araştırmalarına bakıp bir aralık belirle (Ders 54'te maaş rakamlarının neden çok değiştiğini ve hızla eskidiğini konuştuk). İlk konuşmada kesin rakam vermek zorunda değilsin; "Rolün kapsamını öğrendikten sonra konuşmak isterim, araştırmama göre şu aralıktayım" demek normaldir.

#Teknik görüşme ve canlı kodlama

Teknik görüşmede ekipten bir yazılımcı kavram soruları sorar ve projelerini konuşur: "let ile const farkı ne?", "Bu projede veritabanını neden böyle tasarladın?" Canlı kodlamada ise paylaşılan bir editörde ya da ekran paylaşarak küçük bir problem çözersin. Bu dersin büyük kısmı bu iki aşamaya hazırlık.

#Ev ödevi

Bazı şirketler canlı kodlama yerine (ya da onunla birlikte) birkaç günlük süre verip küçük bir proje ister. Gerçek işe en çok benzeyen aşamadır: kodun yanında README, testler ve commit geçmişi de okunur. Ayrı bir bölümde ayrıntılı göreceksin.

#Kültür ve ekip görüşmesi

Son aşamada genelde ekip lideri ya da yönetici, bazen de ekipten birkaç kişi olur. "Bir hatanı anlatır mısın?", "Bir konuda biriyle anlaşamadığın oldu mu?" gibi sorular gelir; bunlara nasıl cevap vereceğini proje anlatma bölümünde öğreneceksin.

Bu aşamada senin soru sorman da beklenir. Görüşmenin sonundaki "Sizin bir sorunuz var mı?" sorusuna "Yok" deme. Hazırda birkaç soru tut:

• "İlk üç ayda benden ne bekliyorsunuz? Başarılı bir junior o sürede ne yapmış olur?"
• "Kod incelemesi (code review) nasıl yapılıyor? Yeni gelenlere bir mentor veriliyor mu?"
• "Ekip hangi teknolojileri kullanıyor, bir özellik fikirden yayına nasıl gidiyor?"
• "Bu pozisyon neden açıldı?"

#Sık sorulan JavaScript soruları

Teknik görüşmenin kavram soruları çoğunlukla aynı havuzdan gelir. Bu bölümde en sık gelen yedi soruyu geçeceksin. Her birinde önce çalışan bir örnek var, sonra mülakatta söyleyeceğin kısa cevap.

#var, let, const ve hoisting

Soru: "var, let ve const arasındaki fark nedir?" Kursta hep let ve const kullandın. Ama internetteki eski kodlarda ve bazı iş yerlerinin eski projelerinde üçüncü bir anahtar sözcük göreceksin: var. Mülakatlarda bu yüzden sorulur. Önce nasıl davrandığına bak. degiskenler.js dosyasına yaz:

1console.log(altin)2var altin = 3003console.log(altin)

undefined300

altin tanımlanmadan önce okundu ama hata çıkmadı, undefined yazdı. Ders 10'da hoisting'i görmüştün: Node dosyayı çalıştırmadan önce okur ve tanımları kayda geçirir. var ile açılan kutu bu okuma turunda hem kayda geçer hem de içine undefined konur. let ve const ile açılan kutu ise kendi satırı çalışana kadar kilitli kalır:

1console.log(seviye)2let seviye = 1

C:\kod\mulakat\degiskenler.js:1console.log(seviye)            ^ ReferenceError: Cannot access 'seviye' before initialization    at Object.<anonymous> (C:\kod\mulakat\degiskenler.js:1:13)    ... Node.js v24.20.0

Kutunun kilitli olduğu bu aralığın adını Ders 10'da duymuştun: temporal dead zone. Mülakatçı soruyu bu adla da sorabilir; "kendi satırı çalışana kadar kilitli kalan aralık" diye açıklaman yeter.

İkinci fark kapsamda. let ve const blok kapsamlıdır: süslü parantezin içinde açılan kutu dışarıdan görünmez. var süslü parantezi dinlemez; yalnız fonksiyonun sınırına bakar.

1if (true) {2    var mana = 503    let can = 1004}5console.log(mana)6console.log(can)

50C:\kod\mulakat\degiskenler.js:6console.log(can)            ^ ReferenceError: can is not defined    at Object.<anonymous> (C:\kod\mulakat\degiskenler.js:6:13)    ... Node.js v24.20.0

mana bloğun dışına sızdı; can sızmadı.

const hakkında da bir tuzak sorusu gelir: "const ile tanımlanan bir dizi değiştirilebilir mi?"

1const takim = ["Ahri"]2takim.push("Lux")3console.log(takim)4takim = ["Garen"]

[ 'Ahri', 'Lux' ]C:\kod\mulakat\degiskenler.js:4takim = ["Garen"]      ^ TypeError: Assignment to constant variable.    at Object.<anonymous> (C:\kod\mulakat\degiskenler.js:4:7)    ... Node.js v24.20.0

const kutunun içindekini dondurmaz; yalnız kutuya başka bir şey konmasını engeller. Dizinin içine eleman eklemek serbest, takim adına yeni bir dizi bağlamak yasak. Bunu Ders 4'te objeler için görmüştün.

1for (var i = 0; i < 3; i++) {2    setTimeout(() => console.log("var:", i), 0)3}4for (let j = 0; j < 3; j++) {5    setTimeout(() => console.log("let:", j), 0)6}

var: 3var: 3var: 3let: 0let: 1let: 2

#== ile ===

Soru: "== ile === arasındaki fark nedir?" Ders 2'de kuralı öğrendin: her zaman ===. Mülakatçı nedenini duymak ister. esitlik.js:

1console.log(0 == "")2console.log(0 == "0")3console.log("" == "0")4console.log(null == undefined)5console.log(null === undefined)6console.log(NaN === NaN)

truetruefalsetruefalsefalse

İlk üç satıra bak: 0 hem boş metne ("") hem "0" metnine eşit, ama bu iki metin birbirine eşit değil. == karşılaştırmadan önce iki tarafı aynı türe çevirmeye çalışır ve bu çevirmenin kuralları sezgiye uymaz. Gündelik mantıkta "A, B'ye eşitse ve A, C'ye eşitse B de C'ye eşittir"; == bu kuralı bile bozuyor.

Son iki satır da birer klasik. null == undefined sonucunun true olması, =='nin işe yarayan tek gevşekliği sayılır: bazı kod tabanlarında "null ya da undefined mı?" diye sormak için yalnız bu kalıpta == kullanılır. NaN ise kendine bile eşit değildir; bir değerin NaN olup olmadığını Ders 9'daki Number.isNaN ile sorarsın.

#Closure

Soru: "Closure nedir, nerede kullanılır?" Ders 10'da sayaç ve bekleme süresi örnekleriyle gördün. Mülakat için yeni bir örnek: dışarıdan doğrudan değiştirilemeyen bir cüzdan. closure.js:

1function cuzdanOlustur(baslangic) {2    let altin = baslangic3    return {4        harca: (miktar) => {5            if (miktar > altin) {6                return false7            }8            altin = altin - miktar9            return true10        },11        bakiye: () => altin12    }13}14 15const cuzdan = cuzdanOlustur(300)16console.log(cuzdan.harca(250))17console.log(cuzdan.harca(100))18console.log(cuzdan.bakiye())19console.log(cuzdan.altin)

truefalse50undefined

cuzdanOlustur çağrılıp bittiğinde altin kutusu ortadan kalkmadı; içerideki iki ok fonksiyonu onu hâlâ görüyor ve değiştiriyor. Dışarıdan cuzdan.altin diye ulaşmak ise mümkün değil: döndürülen objede böyle bir alan yok. Altını değiştirmenin tek yolu harca, o da paranın yetip yetmediğine bakıyor. Ders 16'daki özel alanların (#hp) sınıfsız hâli gibi.

Son cümle React'teki anlık görüntü davranışına bağlanıyor. Bu bağlantıyı kurabilmek, iki konuyu ayrı ayrı ezberlemekten çok daha güçlü bir izlenim bırakır.

#Olay döngüsü

Soru: "Olay döngüsü nedir?" Genelde bir "bu kod hangi sırayla yazar?" sorusuyla gelir. olay-dongusu.js:

1console.log("1: senkron")2setTimeout(() => {3    console.log("2: setTimeout")4}, 0)5Promise.resolve().then(() => {6    console.log("3: then")7})8console.log("4: senkron")

1: senkron4: senkron3: then2: setTimeout

1 ve 4'ün önce gelmesini Ders 15'ten biliyorsun: kuyruktaki hiçbir iş, o anda çalışan kod bitmeden başlamaz. Yeni olan, then'in setTimeout'tan önce çalışması. İkisinin de beklediği bir şey yok; sebep, ayrı kuyruklarda beklemeleri.

await de bu kuyruğu kullanır. await'e gelen bir async fonksiyon orada durur, kalanı mikro görev olarak sıraya girer ve çağıran kod yoluna devam eder:

1async function yukle() {2    console.log("B")3    await null4    console.log("D")5}6 7console.log("A")8yukle()9console.log("C")

ABCD

B, yukle çağrılır çağrılmaz yazıldı: async fonksiyonun ilk await'e kadarki kısmı hemen, senkron çalışır. await null beklenecek gerçek bir iş olmasa da fonksiyonu durdurdu; D ancak dosyanın kalanı (C) bitince geldi.

#Promise ve async/await

Soru: "Promise nedir? async/await ne işe yarar?" İlk ek soru çoğu zaman "Bir async fonksiyon ne döndürür?" olur. async.js:

1async function sampiyonGetir() {2    return "Ahri"3}4 5const sonuc = sampiyonGetir()6console.log(sonuc)7sonuc.then((isim) => {8    console.log(isim)9})

Promise { 'Ahri' }Ahri

return "Ahri" yazsan da async fonksiyon her zaman bir Promise döndürür; değere await ya da then ile ulaşırsın. Ders 15'te Promise { <pending> } çıktısını görmüştün; buradaki Promise çoktan tamamlandığı için içindeki değer de görünüyor.

İkinci sık ek soru, hataların nasıl yakalandığı. Bir tuzakla birlikte gelir:

1async function getir() {2    throw new Error("Sunucu yanıt vermedi")3}4 5async function main() {6    try {7        getir()8    } catch (hata) {9        console.log("Yakalandı:", hata.message)10    }11    console.log("main bitti")12}13 14main()

main bittiC:\kod\mulakat\async.js:2    throw new Error("Sunucu yanıt vermedi")          ^ Error: Sunucu yanıt vermedi    at getir (C:\kod\mulakat\async.js:2:11)    ... Node.js v24.20.0

1async function getir() {2    throw new Error("Sunucu yanıt vermedi")3}4 5async function main() {6    try {7        await getir()8    } catch (hata) {9        console.log("Yakalandı:", hata.message)10    }11    console.log("main bitti")12}13 14main()

Yakalandı: Sunucu yanıt vermedimain bitti

#this

Soru: "this neyi gösterir?" Ders 16'da sınıflarla öğrendin. Mülakatlarda genelde metodu objeden koparan bir örnekle sorulur. this.js:

1class Sampiyon {2    constructor(isim) {3        this.isim = isim4    }5 6    tanit() {7        console.log("Ben " + this.isim)8    }9}10 11const ahri = new Sampiyon("Ahri")12ahri.tanit()13 14const tanit = ahri.tanit15tanit()

Ben AhriC:\kod\mulakat\this.js:7        console.log("Ben " + this.isim)                                  ^ TypeError: Cannot read properties of undefined (reading 'isim')    at tanit (C:\kod\mulakat\this.js:7:35)    ... Node.js v24.20.0

1class Sampiyon {2    constructor(isim) {3        this.isim = isim4    }5 6    tanit() {7        console.log("Ben " + this.isim)8    }9}10 11const ahri = new Sampiyon("Ahri")12const tanit = ahri.tanit.bind(ahri)13tanit()14setTimeout(() => ahri.tanit(), 0)

Ben AhriBen Ahri

12. satır this'i ahri'ye bağlanmış yeni bir fonksiyon üretiyor. 14. satırdaki ok fonksiyonu ise metodu yine ahri.tanit() biçiminde, objesiyle çağırıyor; zamanlayıcıya metodun kendisini değil, bu küçük sarmalayıcıyı veriyoruz.

#Değer ve referans

Soru: "JavaScript'te değerler kopyalanarak mı geçer, referansla mı?" Ders 12'de bütün ayrıntısıyla gördün. Mülakat sürümü referans.js:

1let can = 1002let yedekCan = can3yedekCan = 504console.log(can)5 6const ahri = { isim: "Ahri", hp: 100 }7const ayniObje = ahri8ayniObje.hp = 509console.log(ahri.hp)10 11const kopya = { ...ahri }12kopya.hp = 8013console.log(ahri.hp)14console.log(ahri === ayniObje, ahri === kopya)15console.log({ isim: "Lux" } === { isim: "Lux" })

1005050true falsefalse

Son satır mülakatların sevdiği bir sorudur: içerikleri aynı iki obje bile === ile eşit değil. === objelerde içeriğe değil kimliğe bakar: "aynı obje mi?" Fonksiyona argüman verirken de aynı kural geçerli:

1function iyilestir(sampiyon, miktar) {2    sampiyon.hp = sampiyon.hp + miktar3}4 5function canArttir(hp, miktar) {6    hp = hp + miktar7}8 9const lux = { isim: "Lux", hp: 60 }10let hp = 6011iyilestir(lux, 20)12canArttir(hp, 20)13console.log(lux.hp, hp)

80 60

iyilestir dışarıdaki objeyi değiştirdi, canArttir dışarıdaki sayıyı değiştiremedi. Teknik olarak JavaScript her şeyi kopyalayarak verir; ama obje tutan bir değişkendeki "değer" objenin kendisi değil, referansıdır. Kopyalanan referans da aynı objeyi gösterir.

#React soruları

React sorularında mülakatçı çoğunlukla üç şeyi yoklar: veri bileşenler arasında nasıl akıyor, liste nasıl çiziliyor, yan etkiler nerede yaşıyor. Aşağıdaki kod parçaları Ders 40–42'deki Vite projelerinde çalışacak biçimde yazıldı; burada çalıştırmıyoruz, cevabı desteklemek için okuyorsun.

#State ve props

Soru: "State ile props arasındaki fark nedir?"

1import { useState } from "react"2 3function CanBari({ hp }: { hp: number }) {4    return <p>Can: {hp}</p>5}6 7export default function Sampiyon() {8    const [hp, setHp] = useState(100)9    return (10        <div>11            <CanBari hp={hp} />12            <button onClick={() => setHp(hp - 10)}>Vur</button>13        </div>14    )15}

hp, Sampiyon için state: bileşenin kendisi tutuyor ve setHp ile değiştiriyor. Aynı değer CanBari için props: dışarıdan geliyor, CanBari onu yalnız okuyor. Düğmeye basınca Sampiyon'un state'i değişir, React Sampiyon'u ve onunla birlikte CanBari'yi yeni değerle yeniden çizer.

#key

Soru: "Listelerde key neden gerekli? Sıra numarasını key yapmak neden kötü?" Cevabın tamamı Ders 40'taki şekilde var:

#Effect

Soru: "useEffect ne zaman çalışır? Bağımlılık dizisi ne işe yarar?"

1import { useEffect, useState } from "react"2 3export default function Sayac() {4    const [saniye, setSaniye] = useState(0)5 6    useEffect(() => {7        const zamanlayici = setInterval(() => {8            setSaniye((s) => s + 1)9        }, 1000)10        return () => clearInterval(zamanlayici)11    }, [])12 13    return <p>Maç süresi: {saniye} sn</p>14}

• Effect, bileşen ekrana çizildikten sonra çalışır. Çizim sırasında dış dünyaya dokunulmaz.
• Bağımlılık dizisi ne zaman yeniden çalışacağını söyler. Dizi hiç yoksa her çizimden sonra; [] ise yalnız ilk çizimden sonra; [id] ise ilk çizimde ve id her değiştiğinde.
• Döndürülen fonksiyon temizlik fonksiyonudur. Effect yeniden çalışmadan önce ve bileşen sayfadan kaldırılınca çalışır. Burada zamanlayıcıyı durduruyor; yoksa bileşen gittikten sonra da sayaç dönmeye devam ederdi.
• Geliştirme sırasında katı mod (<StrictMode>) her effect'i bir kez fazladan kurup temizler. Temizliği eksik bir effect'i böylece hemen fark edersin; yayındaki sitede bu olmaz.
• setSaniye((s) => s + 1) yazımı, güncelleme fonksiyonu kullanıyor. setSaniye(saniye + 1) yazsaydın effect yalnız ilk çizimde kurulduğu için hep ilk çizimin saniye'sini, yani 0'ı görürdü; her saniye 0 + 1 hesaplanır, ekran 1'de takılı kalırdı. Bu da bir closure sorusu.

#Kısa sorular

#SQL soruları

SQL soruları junior mülakatlarında genelde üç konuda toplanır: JOIN türleri, indeks ve tablo tasarımı. Örnekler için yeni iki tablo kur. Bu kez şampiyonlar yerine sana daha yakın bir konu var: iş başvuruların. Şirket adları uydurma.

CREATE TABLE sirketler (    id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,    ad text NOT NULL,    sehir text NOT NULL); CREATE TABLE basvurular (    id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,    sirket_id integer REFERENCES sirketler (id),    pozisyon text NOT NULL,    durum text NOT NULL); INSERT INTO sirketler (ad, sehir) VALUES    ('Kuzey Yazılım', 'İstanbul'),    ('Mavi Bulut', 'Ankara'),    ('Piksel Oyun', 'İzmir'),    ('Veri Atölyesi', 'İstanbul'); INSERT INTO basvurular (sirket_id, pozisyon, durum) VALUES    (1, 'Junior Frontend', 'mülakat'),    (1, 'Junior Full Stack', 'red'),    (2, 'Stajyer Yazılımcı', 'bekliyor'),    (3, 'Junior Oyun Geliştirici', 'teklif'),    (NULL, 'Junior Backend (gizli ilan)', 'bekliyor');

İki ayrıntıya dikkat et: Veri Atölyesi'ne henüz başvurmadın, son başvurunun ise şirketi belli değil. Bazı ilanlarda şirket adı gizlenir, bu yüzden sirket_id boş (NULL) bırakılabiliyor. JOIN türlerinin farkı tam da bu iki satırda ortaya çıkacak.

#JOIN türleri

Soru: "INNER JOIN ile LEFT JOIN farkı nedir?" Önce INNER JOIN:

SELECT s.ad, b.pozisyonFROM sirketler AS sINNER JOIN basvurular AS b ON b.sirket_id = s.idORDER BY b.id;

Yalnız iki tarafta da eşi olan satırlar geldi: Veri Atölyesi de gizli ilan da yok. Şimdi LEFT JOIN:

SELECT s.ad, b.pozisyonFROM sirketler AS sLEFT JOIN basvurular AS b ON b.sirket_id = s.idORDER BY s.id, b.id;

Soldaki tablonun (sirketler) bütün satırları geldi; başvurusu olmayan Veri Atölyesi'nin sağ tarafı NULL ile dolduruldu. Ders 36'da bu ikisini kullandın, öteki ikisine yalnız bir bilgi kutusunda değindik. Mülakatta "başka hangi JOIN'ler var?" diye sorulabilir:

SELECT s.ad, b.pozisyonFROM sirketler AS sFULL JOIN basvurular AS b ON b.sirket_id = s.idORDER BY s.id, b.id;

FULL JOIN (tam adıyla FULL OUTER JOIN) iki taraftaki eşsiz satırları da getirdi. RIGHT JOIN ise LEFT'in aynasıdır: sağdaki tablonun bütün satırları gelir. Aynı sonucu tabloların yerini değiştirip LEFT JOIN ile de alabildiğin için pratikte az kullanılır.

#WHERE ile HAVING

Soru: "WHERE ile HAVING farkı nedir?" Ders 34'ten: WHERE satırları gruplamadan önce eler, HAVING grupları gruplamadan sonra eler. "İki ya da daha fazla başvurduğun şirketler" bir grup koşuludur:

SELECT sirket_id, count(*) AS adetFROM basvurularGROUP BY sirket_idHAVING count(*) >= 2;

Aynı koşulu WHERE'e yazarsan Postgres izin vermez, çünkü WHERE çalışırken henüz grup ve sayı yoktur:

SELECT sirket_id, count(*) AS adetFROM basvurularWHERE count(*) >= 2GROUP BY sirket_id;

ERROR:  aggregate functions are not allowed in WHERE

#İndeks

Soru: "İndeks nedir? Her sütuna indeks açar mısın?" Başvuru tablosu büyüdükçe "bu şirkete yaptığım başvurular" sorgusu ve JOIN'ler sirket_id sütununda arama yapacak. Ders 36'daki gibi o sütuna indeks aç ve tablonun indekslerine bak:

CREATE INDEX basvurular_sirket_id_idx ON basvurular (sirket_id);

SELECT indexnameFROM pg_indexesWHERE tablename = 'basvurular'ORDER BY indexname;

basvurular_pkey'i sen açmadın: Postgres her birincil anahtar için kendiliğinden bir indeks açar. Yabancı anahtar sütunları için ise açmaz; JOIN'lerde kullanılan sirket_id'ye indeksi senin açman gerekir.

Son cümledeki EXPLAIN'i ve çıktısındaki sorgu planını Ders 36'da denemiştin. Mülakatçı "indeksin kullanıldığını nereden anlarsın?" diye sorarsa cevap bu.

#Normalizasyon

Soru: "Normalizasyon nedir?" En iyi cevap, yanlış bir tasarımı gösterip düzeltmektir. Şirket bilgisini her başvurunun içine yazsaydın:

CREATE TABLE basvurular_tek_tablo (    id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,    sirket_adi text NOT NULL,    sirket_sehri text NOT NULL,    pozisyon text NOT NULL,    durum text NOT NULL);

Kuzey Yazılım'a iki başvuru yaptın, şirketin adı ve şehri iki satırda yazılı. Şirket taşınırsa iki satırı da düzeltmen gerekir; birini unutursan veri kendi kendisiyle çelişir. Tek bir yazım hatası (Kuzey Yazilim) da aynı şirketi iki şirkete böler. Senin tasarımında şirket bilgisi tek yerde, başvurular ona sirket_id ile işaret ediyor.

#Canlı kodlama: sesli düşünmek

Canlı kodlamada mülakatçı sana küçük bir problem verir ve çözüşünü izler. Çoğu zaman en önemli şey doğru cevap değil, oraya nasıl gittiğindir. Sessizce yazıp bitiren aday, dinleyene hiçbir şey göstermez; takıldığında da yardım alamaz. Düşündüğünü yüksek sesle söyleyen aday ise yanlış bir yola girdiğinde bile mülakatçıya akıl yürütmesini gösterir ve çoğu zaman bir ipucuyla geri döner.

Her problemde aynı beş adımı izle:

Şimdi bu adımları gerçek bir mülakat sorusuyla, baştan sona uygula.

#1. adım: Soruyu netleştir

Mülakatçı: "Şampiyon adlarından oluşan bir dizi alıp en çok tekrar eden adı döndüren bir fonksiyon yazar mısın?"

Hemen yazmaya başlama. Önce soruyu kendi sözlerinle tekrarla ve belirsiz yerleri sor:

Sen: "Anladığım kadarıyla girdi bir metin dizisi, çıktı tek bir ad. Birkaç şey sorayım: Dizi boş gelebilir mi, o zaman ne dönmeli? İki ad eşit sayıdaysa hangisini seçeyim? 'ahri' ile 'Ahri' aynı mı sayılsın?"

Mülakatçı: "Boşsa null dönsün. Eşitlikte dizide önce geçen kazansın. Büyük-küçük harfi dert etme, adlar hep aynı biçimde yazılmış gelecek."

Bu üç soru yarım dakikanı aldı ama problemin üç tuzağını önceden ortaya çıkardı. Mülakatçı bu soruları bekler; hiç sormadan yazmaya başlayan aday çoğunlukla sınır durumlarında takılır.

#2. adım: Örnekleri ve sınır durumlarını yaz

en-cok.js dosyasını aç ve kod yazmadan önce örnekleri yorum olarak yaz. Bunlar birazdan test listen olacak:

// ["Ahri", "Lux", "Ahri", "Jinx"]   -> "Ahri"// ["Lux"]                            -> "Lux"// []                                 -> null// ["Jinx", "Garen", "Garen", "Jinx"] -> "Jinx" (eşitlik)

Biri sıradan durum, üçü sınır durumu: tek eleman, boş dizi, eşitlik. Bunları yüksek sesle söylemek, "bu aday kodunu kırmayı da düşünüyor" demektir.

#3. adım: Planı söyle

Sen: "Diziyi bir kez gezip her adın kaç kez geçtiğini bir objede sayacağım. Sonra objedeki çiftleri gezip sayısı en büyük olanı seçeceğim. Eşitlikte önce geçen kazansın diye yalnız kesin büyükse değiştireceğim; obje anahtarları eklendiği sırayla geldiği için ilk görülen önde olur."

Bu planı yorum olarak da yazabilirsin. Mülakatçı burada "neden obje, neden iki tur?" diye sorabilir; ya da "güzel, devam et" der. Kötü bir planı kod yazmadan önce duyması ikiniz için de zaman kazandırır.

#4. ve 5. adım: Kodla, dene

İlk akla gelen yazım reduce ile olabilir. Yazarken anlat, bitince örnekleri tek tek çalıştır:

1function enCokTekrar(isimler) {2    const sayac = {}3    for (const isim of isimler) {4        sayac[isim] = (sayac[isim] ?? 0) + 15    }6    const enIyi = Object.entries(sayac).reduce((aday, cift) => {7        return cift[1] > aday[1] ? cift : aday8    })9    return enIyi[0]10}11 12console.log(enCokTekrar(["Ahri", "Lux", "Ahri", "Jinx"]))13console.log(enCokTekrar(["Lux"]))14console.log(enCokTekrar([]))

AhriLuxC:\kod\mulakat\en-cok.js:6    const enIyi = Object.entries(sayac).reduce((aday, cift) => {                                        ^ TypeError: Reduce of empty array with no initial value    at Array.reduce (<anonymous>)    ... Node.js v24.20.0

Bu hatayı mülakatta görmek kötü değil, tam tersi: sınır durumunu kendi denemenle yakaladın. Yüksek sesle söyle: "Boş dizide reduce başlangıç değeri istiyor. En büyüğü düz bir döngüyle, null ve 0'dan başlayarak bulayım; böylece boş dizide kendiliğinden null döner."

1// ["Ahri", "Lux", "Ahri", "Jinx"]   -> "Ahri"2// ["Lux"]                            -> "Lux"3// []                                 -> null4// ["Jinx", "Garen", "Garen", "Jinx"] -> "Jinx" (eşitlik)5 6function enCokTekrar(isimler) {7    const sayac = {}8    for (const isim of isimler) {9        sayac[isim] = (sayac[isim] ?? 0) + 110    }11 12    let enIyiIsim = null13    let enIyiSayi = 014    for (const [isim, sayi] of Object.entries(sayac)) {15        if (sayi > enIyiSayi) {16            enIyiIsim = isim17            enIyiSayi = sayi18        }19    }20    return enIyiIsim21}22 23console.log(enCokTekrar(["Ahri", "Lux", "Ahri", "Jinx"]))24console.log(enCokTekrar(["Lux"]))25console.log(enCokTekrar([]))26console.log(enCokTekrar(["Jinx", "Garen", "Garen", "Jinx"]))

PS C:\kod\mulakat> node en-cok.jsAhriLuxnullJinx

Son çıktıları yorumlardaki beklentilerle birlikte oku: "Ahri bekliyordum, Ahri geldi. Boş dizide null. Eşitlikte Jinx, çünkü önce o geçiyor." Mülakatçının "Peki ["Garen", "Jinx", "Jinx", "Garen"] olsa?" diye sorması büyük ihtimal; cevap Garen, çünkü bu kez o önce geçiyor.

#"Daha hızlı yapılabilir mi?"

Çalışan bir çözümden sonra sık gelen bir soru. Aklına gelebilecek başka bir yol: her ad için bütün diziyi yeniden saymak. İkisinin kaç adım attığını ölç. adim.js:

1const isimler = []2for (let i = 0; i < 1000; i++) {3    isimler.push("Şampiyon" + (i % 50))4}5 6// Yol A: her isim için bütün diziyi yeniden say7let adimA = 08for (const aranan of isimler) {9    let kac = 010    for (const isim of isimler) {11        adimA++12        if (isim === aranan) {13            kac++14        }15    }16}17 18// Yol B: diziyi bir kez gez, sayaca yaz; sonra sayacı gez19let adimB = 020const sayac = {}21for (const isim of isimler) {22    adimB++23    sayac[isim] = (sayac[isim] ?? 0) + 124}25adimB = adimB + Object.keys(sayac).length26 27console.log("Yol A:", adimA, "adım")28console.log("Yol B:", adimB, "adım")

Yol A: 1000000 adımYol B: 1050 adım

Yol A'da kac, aranan adın kaç kez geçtiğini sayıyor; en büyüğünü seçme kısmını kısa kalsın diye yazmadık, adım sayısını değiştirmiyor. Bin elemanlı bir dizide iç içe döngü bir milyon adım attı, sayaç objesi bin elli. Dizi on katına çıksa iç içe döngünün adımı yüz katına çıkar, sayacınki yalnız on katına. Mülakatta bunu sözle söylemen yeter: "Benim çözümüm diziyi bir kez geziyor, iç içe döngü yok; dizi büyüdükçe süre de aynı oranda büyüyor."

#Takıldığında

• Sessiz kalma. "Şu an şurada takıldım: boş diziyi nasıl ele alacağımı düşünüyorum" demek, yarım dakika sessizlikten iyidir. Mülakatçı çoğu zaman bir ipucu verir.
• İpucunu al ve kullan. İpucu almak eksi puan değildir; ipucunu duymazdan gelip kendi yanlış yolunda ısrar etmek eksi puandır.
• Önce basit ve doğru, sonra hızlı. "Önce iç içe döngüyle çalışan bir sürüm yazayım, sonra hızlandırırım" demek meşru bir plandır. Hiç çalışmayan zekice bir çözümden iyidir.
• Adı unuttuysan söyle. "Diziyi sıralayan metodun adı sort'tu sanırım, emin değilim" demek normaldir. Hatırlamadığın bir metot için kendi küçük döngünü de yazabilirsin.
• Hata mesajını yüksek sesle oku. Kursun ilk dersinden beri yaptığın şey: dosya, satır, tür, açıklama.

#Projeni anlatmak

"Bize bir projeni anlatır mısın?" sorusu neredeyse her görüşmede gelir. Kötü cevap bir özellik listesidir: "React kullandım, Next.js kullandım, giriş yaptım, Vercel'e attım." Dinleyen kişi bundan senin ne düşündüğünü, neyle uğraştığını öğrenemez. İyi cevap bir hikâyedir: bir problem vardı, şöyle çözdün, yolda şu zorluk çıktı, ondan şunu öğrendin.

En değerli kısım genelde zorluktur. Her şey yolunda giden bir hikâyede mülakatçı senin takılınca ne yaptığını göremez. Kendi kurs projelerinden bir örnek, Ders 38'deki veritabanı taşıma:

Problem: Takım API'm verisini bir JSON dosyasında tutuyordu. Yayına aldığım servisin ücretsiz planında disk geçiciydi; sunucu her yeniden başladığında eklenen takımlar kayboluyordu.

Çözüm: Veriyi PostgreSQL'e taşıdım. Dört ilişkili tablo tasarladım, eski JSON'u tek bir transaction içinde taşıyan bir betik yazdım ve uç noktaları parametreli sorgulara çevirdim. API'yi kullanan sayfalar bozulmasın diye adresleri ve JSON biçimini aynen korudum.

Zorluk: Taşımadan sonra ilk yeni takımı eklerken duplicate key hatası aldım; Postgres yeni takıma 1 numarasını vermeye çalışıyordu. Eski kayıtları kendi numaralarıyla taşıdığım için kimlik sayacı hiç ilerlememişti. setval ile sayacı en büyük numaraya getirdim ve bu adımı taşıma betiğine ekledim.

Öğrendiğim: Veri taşımak yalnız satırları kopyalamak değil; sayaç gibi görünmeyen durumun da taşınması gerekiyor. Artık her taşımadan sonra bir ekleme denemesi yapıyorum.

Yüksek sesle okuyunca bir dakika kadar sürer. Mülakatçının ek soruları buradan çıkar: "Neden PostgreSQL? Neden transaction? Betik ikinci kez çalışırsa ne olur?" Bunların cevapları da senin projende. Bu yüzden anlattığın her projenin kodunu mülakattan önceki gün bir kez aç ve göz gezdir.

Takım API'si yaptım. Expresskullandım, PostgreSQLkullandım, Neon'da veritabanıaçtım, Render'a yükledim.Sayfalama ve arama da var.

Takımlar, sunucu her yenidenbaşladığında kayboluyordu.Veriyi PostgreSQL'e taşıdım.Taşımadan sonra kimlik sayacıyüzünden ekleme bozuldu;setval ile düzeltip betiğeekledim. Artık her taşımadansonra bir ekleme deniyorum.

İki dürüstlük kuralı:

• "Biz" değil "ben". Ekip projesinde senin yaptığın kısmı ayır: "Ekip olarak bir uygulama yaptık; ben giriş ve yetki kısmını yazdım." Mülakatçı seni işe alacak, ekibini değil.
• Kurs projesi olduğunu saklama. "Bir kursta yaptığım projenin üzerine şunları ekledim" demek zayıflık değil. Kurs projeleri birçok adayda aynıdır; seni ayıran, kendi eklediğin özellikler ve verdiğin kararlardır. Görevlerdeki genişletmeleri yaptıysan onları anlat.

#Davranışsal sorular

Kültür görüşmesinde "Bana … yaşadığın bir zamanı anlatır mısın?" kalıbında sorular gelir. Bunlar da STAR ile cevaplanır.

Sık gelenler ve kurs boyunca yaşadıklarından hangisinin işe yarayabileceği:

• "Bir hatanı anlat." Aranan: hatayı sahiplenmek ve ders çıkarmak. Hikâye fikri: sınır durumunu atladığın bir görev; boş listede NaN ya da çöken bir reduce, nasıl fark edip düzelttiğin.
• "Uzun süre takıldığın bir sorun oldu mu?" Aranan: sistemli hata ayıklama. Hikâye fikri: kimlik sayacı ya da kaybolan this; tahmin et, ölç, daralt adımlarıyla nasıl bulduğun (Ders 7).
• "Bilmediğin bir şeyi hızla öğrenmen gerekti mi?" Aranan: öğrenme yöntemin. Hikâye fikri: yapay zekâ bloğu; belgeyi okuyup önce sahte istemciyle denemek (Ders 50).
• "Biriyle anlaşamadığın oldu mu?" Aranan: saygılı itiraz, ortak çözüm. Hikâye fikri: bir pull request incelemesinde gelen yorum (Ders 52) ya da bir takım projesi; gerekçeni anlatıp ortada buluşmak.

Bunlar yalnız fikir; gerçekten yaşadığın olayı anlat. İş deneyimin yoksa okul, staj, bir topluluk ya da oyun takımından örnek vermek de olur. Uydurma hikâye ilk ek soruda dağılır.

#"Bilmiyorum ama şöyle bulurum"

Her mülakatta bilmediğin bir soru gelecek. Bu kaçınılmaz; asıl soru o anda ne yaptığın. Yanlış iki yol var: uydurmak ya da "bilmiyorum" deyip susmak. Uydurulan cevap mülakatçının ilk ek sorusunda ortaya çıkar ve diğer doğru cevaplarına da gölge düşürür. Yalnız "bilmiyorum" ise sana fırsat vermez.

Doğru yol dört adımlıdır:

Bir örnek. React sorularının arasına şu gelsin: "React'te reconciliation nedir?" Bu kursta terimin İngilizcesini hiç kullanmadık. Ama konuyu biliyorsun:

Reconciliation, React'instate'i sunucuylaeşitlemesidir. Veriyiveritabanına yazar.

Terimi bu adla duymadım."Uzlaştırma" demek; React'ineski listeyle yeni listeyikey'e bakarakkarşılaştırmasıyla ilgiliolabilir. Yanılıyorolabilirim; react.dev'debakar, küçük bir listeyledenerim.

İkinci cevap doğru yolda: React her yeniden çizimde yeni arayüz tarifini öncekiyle karşılaştırır ve sayfada yalnız değişen kısımları günceller. key'in işi tam da bu karşılaştırmada öğeleri eşlemektir.

Aynı kalıp araç sorularında da işe yarar. "Docker kullandın mı?" sorusuna cevap: "Kullanmadım. Projelerimi Render ve Vercel'e yayına aldım; ortam değişkenlerini barındırıcıda tanımladım, logları okudum. Docker'ın uygulamayı bağımlılıklarıyla birlikte paketleyip her yerde aynı ortamda çalıştırdığını biliyorum; öğrenme listemde ilk sırada." Bilmediğini söyledin, ama yanındaki tecrübeni ve merakını da gösterdin.

#Ev ödevi

Ev ödevi, mülakat aşamaları arasında gerçek işe en çok benzeyenidir. Bir görev tarifi gelir, birkaç gün süre verilir, sonunda bir GitHub deposu ya da sıkıştırılmış bir klasör teslim edersin. Kodu okuyan kişi aynı zamanda senin README'ni, testlerini ve commit geçmişini de okur.

Değerlendiren kişinin baktıkları, kabaca önem sırasıyla:

1. Çalışıyor mu? README'deki komutlarla, senin bilgisayarın olmadan, ilk denemede çalışmalı.
2. İstenen yapılmış mı? Tarifteki her madde. Fazlası artı değil; eksik bir zorunlu madde büyük eksi.
3. Okunur mu? Anlamlı adlar, küçük fonksiyonlar, tutarlı biçim.
4. Test var mı? Sınır durumlarını da kapsayan birkaç anlamlı test.
5. README ve kararlar. Nasıl çalıştırılır, neyi varsaydın, neyi bilerek yapmadın.
6. Commit geçmişi. Adım adım ilerlediğin görülüyor mu?

#Örnek: maç özeti modülü

Tarif şöyle olsun: "Bir oyuncunun maç listesini alıp kazanma oranını ve en çok oynadığı şampiyonu döndüren bir JavaScript modülü yaz. Testleri ve README'si olsun. Süre üç gün, beklenen emek 3–4 saat." Proje klasörü C:\kod\mac-ozeti, içinde package.json'da "type": "module" ve "test": "node --test" betiği (Ders 14, Ders 53).

1export function kazanmaOrani(maclar) {2    if (maclar.length === 0) {3        return 04    }5    const galibiyet = maclar.filter((mac) => mac.sonuc === "G").length6    return Math.round((galibiyet / maclar.length) * 100)7}8 9export function enCokOynanan(maclar) {10    const sayac = {}11    for (const mac of maclar) {12        sayac[mac.sampiyon] = (sayac[mac.sampiyon] ?? 0) + 113    }14 15    let enIyiIsim = null16    let enIyiSayi = 017    for (const [isim, sayi] of Object.entries(sayac)) {18        if (sayi > enIyiSayi) {19            enIyiIsim = isim20            enIyiSayi = sayi21        }22    }23    return enIyiIsim24}

enCokOynanan, canlı kodlamada yazdığın fonksiyonun aynısı; yalnız adları objelerin sampiyon alanından sayıyor. Testler ayrı bir dosyada:

1import { test } from "node:test"2import assert from "node:assert/strict"3import { kazanmaOrani, enCokOynanan } from "./ozet.js"4 5const maclar = [6    { sampiyon: "Ahri", sonuc: "G" },7    { sampiyon: "Lux", sonuc: "M" },8    { sampiyon: "Ahri", sonuc: "G" },9    { sampiyon: "Jinx", sonuc: "G" }10]11 12test("kazanma oranı yüzde olarak yuvarlanır", () => {13    assert.equal(kazanmaOrani(maclar), 75)14})15 16test("maç yoksa kazanma oranı 0", () => {17    assert.equal(kazanmaOrani([]), 0)18})19 20test("en çok oynanan şampiyonu bulur", () => {21    assert.equal(enCokOynanan(maclar), "Ahri")22})23 24test("eşitlikte listede önce geçen seçilir", () => {25    const esit = [26        { sampiyon: "Jinx", sonuc: "M" },27        { sampiyon: "Garen", sonuc: "G" },28        { sampiyon: "Garen", sonuc: "M" },29        { sampiyon: "Jinx", sonuc: "G" }30    ]31    assert.equal(enCokOynanan(esit), "Jinx")32})33 34test("maç yoksa en çok oynanan null", () => {35    assert.equal(enCokOynanan([]), null)36})

Beş testten üçü sınır durumu: boş liste iki kez, eşitlik bir kez. Değerlendiren kişi testlerin adlarını okuyarak senin hangi durumları düşündüğünü görür; test adlarını cümle gibi yazmanın sebebi bu.

PS C:\kod\mac-ozeti> npm test > mac-ozeti@1.0.0 test> node --test ✔ kazanma oranı yüzde olarak yuvarlanır (0.6841ms)✔ maç yoksa kazanma oranı 0 (0.1042ms)✔ en çok oynanan şampiyonu bulur (0.6309ms)✔ eşitlikte listede önce geçen seçilir (0.1255ms)✔ maç yoksa en çok oynanan null (0.1192ms)ℹ tests 5ℹ suites 0ℹ pass 5ℹ fail 0ℹ cancelled 0ℹ skipped 0ℹ todo 0ℹ duration_ms 77.5566

Süreler (ms) her çalıştırmada biraz farklı çıkar.

PS C:\kod\mac-ozeti> npm test > mac-ozeti@1.0.0 test> node --test ✔ kazanma oranı yüzde olarak yuvarlanır (0.9131ms)✖ maç yoksa kazanma oranı 0 (1.087ms)ℹ tests 2ℹ suites 0ℹ pass 1ℹ fail 1ℹ cancelled 0ℹ skipped 0ℹ todo 0ℹ duration_ms 114.6365 ✖ failing tests: test at ozet.test.js:16:1✖ maç yoksa kazanma oranı 0 (1.087ms)  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:   NaN !== 0       at TestContext.<anonymous> (file:///C:/kod/mac-ozeti/ozet.test.js:17:12)      ...

#README

README, değerlendiren kişinin açtığı ilk dosyadır. Ders 7'de öğrendiğin Markdown'la, şu bölümleri kapsayan kısa bir metin yeter:

1# Maç özeti2 3Bir oyuncunun maç geçmişinden kazanma oranını ve en çok oynadığı şampiyonu çıkaran küçük bir JavaScript modülü. Piksel Oyun'un junior geliştirici başvurusu için ev ödevi olarak yazıldı.4 5## Çalıştırma6 7Node.js 24 gerekir, dış paket yok.8 9```sh10npm test11```12 13## Kullanım14 15```js16import { kazanmaOrani, enCokOynanan } from "./ozet.js"17 18const maclar = [19    { sampiyon: "Ahri", sonuc: "G" },20    { sampiyon: "Lux", sonuc: "M" }21]22kazanmaOrani(maclar)   // 5023enCokOynanan(maclar)   // "Ahri"24```25 26## Varsayımlar27 28- `sonuc` alanı "G" (galibiyet) ya da "M" (mağlubiyet) olur.29- Kazanma oranı yüzde olarak, en yakın tam sayıya yuvarlanır.30- Maç yoksa oran 0, en çok oynanan şampiyon `null` döner.31- Eşitlikte listede önce geçen şampiyon seçilir.32 33## Zamanım olsaydı34 35- Girdiyi doğrulardım: `sonuc` alanında "G" ve "M" dışında bir değer gelirse açık bir hata fırlatırdım.36- Şampiyon adlarını büyük-küçük harf farkı gözetmeden sayardım ("ahri" ile "Ahri" aynı sayılsın).37 38## Süre39 40Yaklaşık 3 saat.

Varsayımlar bölümü en çok atlanan ama en çok işe yarayan bölümdür. Tarifte boş liste için ne dönmesi gerektiği yazmıyordu; sen bir karar verdin ve bunu açıkça yazdın. Değerlendiren kişi kararına katılmasa bile düşündüğünü görür.

#Commit geçmişi

Bütün işi tek bir "bitti" commit'inde teslim etme. Küçük ve anlamlı adımlarla ilerle; geçmiş, nasıl çalıştığını anlatsın. Mesajları Ders 52'deki Conventional Commits biçiminde yazdık:

PS C:\kod\mac-ozeti> git log --onelinea7126d0 (HEAD -> main) docs: kullanımı ve varsayımları yaz5e90c58 feat: en çok oynanan şampiyonu bul31e84c2 fix: maç yoksa kazanma oranını 0 döndür00a4bc0 feat: kazanma oranını hesaplab168d58 chore: proje iskeletini kur

Her satır bir adım, her mesaj ne yapıldığını söylüyor; baştaki tür de neyin değiştiğini bir bakışta gösteriyor: yeni özellik (feat), hata düzeltme (fix), belge (docs), bakım işi (chore). Her feat commit'i kendi testleriyle birlikte girdi. Ortadaki fix satırı, yukarıdaki hata kartındaki düzeltmenin ta kendisi. Kayıt kimlikleri sende farklı olur. Aynı beş adımın bir de şu hâlini düşün:

f321b8b (HEAD -> main) sonee3f22a düzeltme8816ead asdf9f51177 çalışıyor galiba4f28feb ilk

Bu geçmişten hiçbir şey öğrenilmez: hangi commit neyi değiştirdi, test ne zaman eklendi, hata nerede düzeltildi? Değerlendiren kişi bunu "çalışırken düşünmüyor" diye okur. İyi commit mesajının kuralını Ders 7'de ve Ders 52'de gördün: ne yaptığını emir kipiyle söyleyen kısa bir cümle (ekle, düzelt, döndür), her commit'te tek iş. Şirketin ilanında ya da ödev tarifinde başka bir biçim isteniyorsa ona uy.

#Teslimden önce

Son adım: projeyi temiz bir klasöre indirip yalnız README'deki komutlarla çalıştır. Senin bilgisayarında çalışan ama depoya girmemiş bir dosya, .gitignore'a takılmış bir ayar ya da elle kurduğun bir paket burada ortaya çıkar. GitHub'a gönderdikten sonra, kendi adresinle:

cd C:\kodgit clone https://github.com/kullanici-adin/mac-ozeti.git mac-ozeti-denemecd mac-ozeti-denemenpm installnpm test

Testler geçiyorsa deneme klasörünü sil ve teslim et.

#Mülakattan sonra

Görüşme bittiğinde iş bitmez:

• Aynı gün not al. Gelen soruları, bilemediklerini, sana söylenen sonraki adımı yaz. Bilemediklerinin cevabını o gün öğren.
• Kısa bir teşekkür e-postası gönderebilirsin. Zorunlu değil ama iyi bir izlenimi pekiştirir. Üç dört cümle yeter:

Konu: Görüşme için teşekkürler Merhaba Ece Hanım, Bugünkü görüşme için teşekkür ederim.Ekibin kod incelemesini nasıl yaptığınıanlatmanız özellikle ilgimi çekti.Konuştuğumuz canlı kodlama sorusundaeşitlik durumunu sonradan bir kez dahadüşündüm; çözümüm aynı kalıyor,testlerini de yazdım. Süreçteki birsonraki adımı bekliyorum. İyi çalışmalar,Deniz

• Başvuru takibine işle. Ders 54'te kurduğun başvuru takibine tarihi, aşamayı ve bir sonraki adımı yaz.
• Ret gelirse kişisel algılama; junior ilanlarına çok sayıda kişi başvurur. Kısa ve kibar bir e-postayla geri bildirim isteyebilirsin. Her şirket vermez; veren olursa altın değerindedir.
• Teklif gelirse yazılı iste: maaş, yan haklar, çalışma biçimi (ofis, uzaktan, karma), başlangıç tarihi, deneme süresi. Düşünmek için birkaç gün istemek normaldir.

#İşe girdikten sonra: ilk 90 gün

Teklifi kabul ettin, ilk gün geldi. Kimse senden ilk hafta özellik yazmanı beklemez. İlk aylar öğrenmek, güven kazanmak ve küçük ama gerçek katkılarla geçer.

• 1–30. gün: öğren ve kur. Projeyi kendi bilgisayarında çalıştır; kurulum belgesinde eksik bulduğun adımları düzelt. Küçük bir hatayı düzeltip ilk pull request'ini birleştir. Ekipteki herkesle tanış.
• 31–60. gün: katkı ver. Küçük bir özelliği baştan sona yap: veritabanı, API, arayüz, test. Başkalarının PR'larını oku, soru sor. Bir konuda "bunu ona sorabilirsiniz" denecek kadar derinleş.
• 61–90. gün: sahiplen. Orta boy bir işi planlayıp bitir. Yöneticinle ilk üç ayı değerlendir, bir sonraki üç ay için hedef koy.

İlk günden itibaren bir not dosyası tut: kurulumda takıldığın yerler, öğrendiğin komutlar, kime ne sorulacağı. Hem sana hem senden sonra gelen kişiye işe yarar; kurulum belgesini düzeltmek yeni gelen birinin yapabileceği en değerli ilk katkılardan biridir.

#Soru sormak

Yeni başlayan biri iki hatadan birine düşer: ya her takıldığı anda sorar, ya da günlerce tek başına uğraşıp hiç sormaz. İkincisi daha zararlıdır. Kendine bir süre koy: bir sorunla 30–60 dakika uğraştıysan ve ilerlemiyorsan sor. Sorarken karşındakinin zamanını düşün; ne denediğini de yaz:

Merhaba Can, kayıt formunda takıldım.Amaç: yeni kullanıcı kaydolunca hoşgeldin e-postası gitsin.Denediğim: e-posta fonksiyonunu kayıtişleminin sonuna ekledim; kendibilgisayarımda çalışıyor.Sorun: test ortamında e-posta gitmiyor;loglarda e-posta sunucusu ayarının boşgeldiği görünüyor.Sorum: test ortamının ortam değişkenlerinerede tanımlı, yenisini ben mieklemeliyim?

Amaç, denediğin, sorun, soru: bu dört parça soruyu cevaplamayı kolaylaştırır. Çoğu zaman mesajı yazarken cevabı kendin bulursun; bu da lastik ördek yönteminin yazılı hâli.

Kod incelemesinde gelen yorumları kişisel algılama. "Burada adı daha açık yaz" yorumu sana değil koda yapılmıştır. Anlamadığın yorumu sor, katılmadığına gerekçeyle cevap ver, ikisinde de teşekkür et.

#Öğrenmeye devam: yol haritası

Kurs seni junior seviyesine hazırladı; işte öğrenme hızlanarak sürecek. İş yerindeki ihtiyaç zaten yön gösterir, ama işe girmeden önce ya da ilk aylarda sırayla şu dört konuya yönel:

1. Docker. Uygulamayı bağımlılıklarıyla birlikte bir kutuya (konteyner) koyar; "benim bilgisayarımda çalışıyordu" sorununu bitirir. Çoğu şirket kullanır. İlk adım: resmî "Get started" rehberi (docs.docker.com/get-started); sonra takım API'ni bir konteynerde çalıştır.
2. Bulut. Render ve Vercel, bulutun üzerine kurulu kolay katmanlar. Büyük şirketler AWS, Google Cloud ya da Azure'u doğrudan kullanır. İlk adım: bir sağlayıcı seç; sunucu, veritabanı, depolama ve yetki kavramlarını onun belgelerinden öğren. Harcama sınırı koymadan hiçbir şey açma.
3. Test derinliği. Bu kursta birim testi yazdın. Sıradaki adım API'yi gerçek veritabanıyla deneyen entegrasyon testleri ve tarayıcıyı süren uçtan uca testler. İlk adım: Playwright (playwright.dev); npm init playwright@latest ile kur, ansiklopedinin arama kutusuna bir test yaz.
4. Sistem tasarımı temelleri. Kıdem arttıkça "milyon kullanıcıda bu nasıl çalışır?" sorusu gelir: önbellek, kuyruk, yük dengeleme, veritabanı kopyaları. İlk adım: system-design-primer deposu (İngilizce); kendi projelerinin darboğazını düşünerek oku.

Algoritma ağırlıklı mülakat yapan şirketlere (büyük teknoloji şirketleri genelde böyledir) başvuracaksan listeye veri yapıları ve algoritmalar başlığını da ekle: diziler, objeler (hash tablosu), yığın, kuyruk, ağaç, sıralama ve arama, zaman karmaşıklığı. Her gün bir küçük problem çözmek, haftada bir uzun çalışmaktan daha iyi sonuç verir.

Belgelerin ve araçların arayüzü değişebilir; yukarıdaki komutlar ve adresler bu ders yazılırken (Ekim 2026) doğrulandı. Bir adres taşınmışsa aracın adını arayıp resmî sitesine git.

#Görevler

Her görevi C:\kod\mulakat klasöründe, görevde yazan dosyada yap; SQL görevini dersteki tablolarla Neon'un SQL Editor'ünde. Önce kendin dene; takılırsan ipuçlarını sırayla aç. Canlı kodlama görevlerinde beş adımı izle ve yüksek sesle söyle; evde tek başınayken bile.

[ ] Yüksek sesle 60–120 saniye sürüyor.[ ] Problem bir sorunla başlıyor,    teknoloji listesiyle değil.[ ] Zorlukta gerçek bir takılma var:    belirtisi, mesajı ya da sayısıyla.[ ] Zorluğu nasıl bulup çözdüğün yazıyor.[ ] Öğrendiğim kısmı, bugün farklı    yaptığın somut bir alışkanlık.[ ] Cümleler "ben" ile kurulu; kurstan    gelenle senin eklediğin ayrı.

const garen = { isim: "Garen", seviye: 6 }const yeniGaren = seviyeAtlat(garen)console.log(garen)console.log(yeniGaren)console.log(garen === yeniGaren) const lux = { isim: "Lux", seviye: 18 }console.log(seviyeAtlat(lux))console.log(seviyeAtlat({ isim: "Jinx", seviye: 17 }))

{ isim: 'Garen', seviye: 6 }{ isim: 'Garen', seviye: 7 }false{ isim: 'Lux', seviye: 18 }{ isim: 'Jinx', seviye: 18 }

1function seviyeAtlat(sampiyon) {2    if (sampiyon.seviye >= 18) {3        return { ...sampiyon }4    }5    return { ...sampiyon, seviye: sampiyon.seviye + 1 }6}7 8const garen = { isim: "Garen", seviye: 6 }9const yeniGaren = seviyeAtlat(garen)10console.log(garen)11console.log(yeniGaren)12console.log(garen === yeniGaren)13 14const lux = { isim: "Lux", seviye: 18 }15console.log(seviyeAtlat(lux))16console.log(seviyeAtlat({ isim: "Jinx", seviye: 17 }))

{ isim: 'Garen', seviye: 6 }{ isim: 'Garen', seviye: 7 }false{ isim: 'Lux', seviye: 18 }{ isim: 'Jinx', seviye: 18 }

const mantar = sarjOlustur(2)console.log(mantar())console.log(mantar())console.log(mantar()) const bos = sarjOlustur(0)console.log(bos()) const ikinci = sarjOlustur(1)console.log(ikinci())console.log(mantar())

Mantar kondu, kalan şarj: 1Mantar kondu, kalan şarj: 0Şarj yokŞarj yokMantar kondu, kalan şarj: 0Şarj yok

1function sarjOlustur(adet) {2    let kalan = adet3    return () => {4        if (kalan === 0) {5            return "Şarj yok"6        }7        kalan = kalan - 18        return "Mantar kondu, kalan şarj: " + kalan9    }10}11 12const mantar = sarjOlustur(2)13console.log(mantar())14console.log(mantar())15console.log(mantar())16 17const bos = sarjOlustur(0)18console.log(bos())19 20const ikinci = sarjOlustur(1)21console.log(ikinci())22console.log(mantar())

Mantar kondu, kalan şarj: 1Mantar kondu, kalan şarj: 0Şarj yokŞarj yokMantar kondu, kalan şarj: 0Şarj yok

console.log(enUzunSeri(["G", "G", "M", "G", "G", "G", "M"]))console.log(enUzunSeri(["G", "M", "G", "G"]))console.log(enUzunSeri([]))console.log(enUzunSeri(["M", "M"]))console.log(enUzunSeri(["G", "G", "G"]))

32003

1// ["G", "G", "M", "G", "G", "G", "M"] -> 32// []                                    -> 0 (maç yok)3// ["M", "M"]                            -> 0 (galibiyet yok)4// ["G", "G", "G"]                       -> 3 (dizi galibiyetle bitiyor)5 6// Plan: diziyi bir kez gez. G'de şu anki seriyi artır, en uzunu güncelle.7// M'de şu anki seriyi sıfırla.8 9function enUzunSeri(sonuclar) {10    let enUzun = 011    let simdiki = 012    for (const sonuc of sonuclar) {13        if (sonuc === "G") {14            simdiki++15            if (simdiki > enUzun) {16                enUzun = simdiki17            }18        } else {19            simdiki = 020        }21    }22    return enUzun23}24 25console.log(enUzunSeri(["G", "G", "M", "G", "G", "G", "M"]))26console.log(enUzunSeri(["G", "M", "G", "G"]))27console.log(enUzunSeri([]))28console.log(enUzunSeri(["M", "M"]))29console.log(enUzunSeri(["G", "G", "G"]))

32003

SELECT s.ad, count(*) AS basvuruFROM sirketler AS sLEFT JOIN basvurular AS b ON b.sirket_id = s.idGROUP BY s.id, s.adORDER BY basvuru DESC, s.ad;

SELECT s.ad, count(b.id) AS basvuruFROM sirketler AS sLEFT JOIN basvurular AS b ON b.sirket_id = s.idGROUP BY s.id, s.adORDER BY basvuru DESC, s.ad;

console.log(enCokUc(["Lux", "Ahri", "Jinx", "Ahri", "Garen", "Jinx", "Ahri", "Teemo", "Garen"]))console.log(enCokUc(["Lux", "Ahri", "Lux"]))console.log(enCokUc([]))console.log(enCokUc(["Teemo", "Annie", "Garen", "Yasuo"]))

[ 'Ahri (3)', 'Jinx (2)', 'Garen (2)' ][ 'Lux (2)', 'Ahri (1)' ][][ 'Teemo (1)', 'Annie (1)', 'Garen (1)' ]

1function enCokUc(isimler) {2    const sayac = {}3    for (const isim of isimler) {4        sayac[isim] = (sayac[isim] ?? 0) + 15    }6    return Object.entries(sayac)7        .toSorted((a, b) => b[1] - a[1])8        .slice(0, 3)9        .map(([isim, sayi]) => isim + " (" + sayi + ")")10}11 12console.log(enCokUc(["Lux", "Ahri", "Jinx", "Ahri", "Garen", "Jinx", "Ahri", "Teemo", "Garen"]))13console.log(enCokUc(["Lux", "Ahri", "Lux"]))14console.log(enCokUc([]))15console.log(enCokUc(["Teemo", "Annie", "Garen", "Yasuo"]))

[ 'Ahri (3)', 'Jinx (2)', 'Garen (2)' ][ 'Lux (2)', 'Ahri (1)' ][][ 'Teemo (1)', 'Annie (1)', 'Garen (1)' ]

#Kendini sına

console.log(puan)var puan = 10console.log(bonus)let bonus = 5

const takim = ["Garen", "Lux", "Jinx"]for (var i = 0; i < takim.length; i++) {    setTimeout(() => {        console.log((i + 1) + ". sırada: " + takim[i])    }, 0)}

setTimeout(() => console.log("A"), 0)console.log("B")Promise.resolve().then(() => console.log("C"))console.log("D")

class Kule {    constructor() {        this.hasar = 150    }     vur() {        return this.hasar    }} const kule = new Kule()const vur = kule.vurconsole.log(kule.vur())console.log(vur())

#Son kontrol listesi

Bu ders bir commit ile değil, bu listeyle bitiyor. İlk başvurundan önce her maddeyi bir kez işaretle; mülakat sabahı yalnız son bölüme bak.

Başvurmadan önce

• GitHub profilinde en iyi üç proje sabitlenmiş; her birinin README'sinde ne yaptığı, nasıl çalıştırıldığı ve bir ekran görüntüsü ya da canlı bağlantısı var (Ders 54).
• Her proje için problem, çözüm, zorluk, öğrendiğin hikâyesi hazır ve en az bir kez yüksek sesle söylendi.
• 30–45 saniyelik kendini tanıtma metni ezbere değil, rahatça söylenebilir durumda.
• Bu dersteki yedi JavaScript sorusunun, üç React ve üç SQL sorusunun kısa cevaplarını notlarına bakmadan söyleyebiliyorsun.
• Görevlerdeki canlı kodlama sorularını bir kez de süre tutarak, yüksek sesle çözdün.

Mülakattan önceki gün

• Şirketin sitesine, ürününe ve ilan metnine yeniden baktın; ilandaki teknolojilerden hangilerini kullandığını, hangilerini kullanmadığını biliyorsun.
• Kültür görüşmesinde soracağın üç soru yazılı.
• Anlatacağın projelerin kodunu açıp göz gezdirdin.
• Çevrim içi görüşmeyse kamera, mikrofon ve ekran paylaşımı denendi; kod editörün ve terminalin büyük yazıyla açık.

Mülakat günü

• Su, kâğıt, kalem.
• Soruyu tekrar et, belirsizliği sor, düşündüğünü söyle.
• Bilmediğinde: bilmiyorum, bildiğim en yakın şey şu, şöyle bulurum.
• Görüşme biter bitmez: sorular ve bilemediklerin not edildi, başvuru takibine işlendi.

#Yolun buraya kadarı

Kurs, "program ne demek?" sorusuyla başladı. Şimdi geriye dönüp bak:

İlk derste console.log("Hoş geldin") yazıp bir hata mesajını dört adımda okumayı öğrendin. Şimdi elinde bir veritabanına bağlanan, kullanıcı girişi olan, yayında çalışan ve bir dil modeliyle konuşan uygulamalar var. Bu, junior tam yığın ilanlarının çoğunda istenen yığının temeli. Her şeyi ezbere bildiğin anlamına gelmiyor; bilmediğin bir şeyi nasıl öğreneceğini bildiğin anlamına geliyor. Mülakatlarda da işte de asıl ölçülen bu.

Bu kursu baştan sona yaptıysan yüzlerce hata mesajı okudun, onlarca görevi kendi elinle yazdın ve takıldığın her yerden yürüyerek çıktın. Bu, tek başına çalışmayı ve takılınca vazgeçmemeyi gösteriyor; işe alımda tam olarak aranan şey. İlk başvurular ret de getirebilir. Her görüşmeden sonra listeni güncelle, bir sonrakine o listeyle gir.

Bu kursun son dersiydi; sonraki ders yok. Bundan sonrası senin projelerin, başvuruların ve ilk iş gününde açacağın ilk pull request.