AI Kodunu Doğrulama: Çalışıyor mu, Doğru mu?

AI kod doğrulama sürecinde ilk sorulması gereken soru, kodun hata vermeden çalışıp çalışmadığı değil, verilen her geçerli girdide beklenen sonucu üretip üretmediğidir. Bir kodun derlenmesi veya normal bir örnek üzerinde sonuç vermesi yalnızca belirli bir senaryonun yürüdüğünü gösterir; kodun doğru olduğunu tek başına kanıtlamaz.

Bu nedenle “çalışıyor”, “beklenen sonucu veriyor” ve “hata durumlarını güvenle yönetiyor” ifadelerini birbirinden ayırmak gerekir. Kodun davranışını anlamak, varsayımlarını görmek ve sınır durumlarını denemek; yapay zekâ ile kod yazma sürecinin doğal bir parçasıdır.

AI’ın Yazdığı Kodun Çalışması Neden Doğru Olduğu Anlamına Gelmez?

Bir programın çalışması genellikle en az üç farklı anlama gelebilir:

• Çalışıyor: Kod sözdizimi açısından geçerlidir ve çalıştırıldığında hemen durmaz.
• Beklenen sonucu veriyor: Belirli bir girdide elde edilen çıktı, problemin kurallarına uygundur.
• Hata durumlarını güvenle yönetiyor: Boş, eksik, beklenmeyen veya sınırdaki girdilerde nasıl davranacağı önceden düşünülmüştür.

AI tarafından üretilen bir kod ilk iki örnek girdide sorunsuz sonuç verebilir. Ancak bu, üçüncü koşulun da sağlandığı anlamına gelmez. Örneğin bir listedeki belirli konumda bulunan sayıyı döndüren basit bir fonksiyonu ele alalım:

def listedeki_degeri_getir(degerler, sira):
    return degerler[sira]

sayilar = [10, 20, 30]
print(listedeki_degeri_getir(sayilar, 1))

Bu kod çalışır ve ekrana 20 yazdırır. Normal girdi olan üç elemanlı bir listede, geçerli bir sıra numarasıyla çağrıldığında beklenen sonucu üretir. Fakat aynı fonksiyonun farklı girdiler karşısındaki davranışı ayrıca incelenmelidir:

Buradaki önemli nokta, her davranışın otomatik olarak “hata” sayılmamasıdır. Python’da negatif indeks kullanımı geçerli bir özelliktir. Fakat bir uygulamanın iş kuralı “sıra numarası sıfır veya daha büyük olmalıdır” diyorsa, -1 değerinin son elemanı döndürmesi teknik olarak çalışan ama iş açısından yanlış bir sonuç olabilir.

Benzer bir ayrım toplam alma işleminde de görülür. Bir fonksiyon normal sayılardan oluşan bir listeyi topladığında beklenen sonucu verebilir. Ancak şu sorular cevaplanmadan fonksiyonun doğru olduğu söylenemez:

• Boş liste için sonuç 0 mı olmalı, yoksa kullanıcıya uyarı mı gösterilmeli?
• Liste içinde None bulunursa işlem devam etmeli mi?
• Negatif sayılar geçerli mi, yoksa reddedilmeli mi?
• Ondalıklı sayılar destekleniyor mu?
• Tek elemanlı listede o elemanın kendisi mi döndürülmeli?
• Liste yerine yanlışlıkla metin veya başka bir veri türü gönderilirse ne yapılmalı?

Bu soruların cevabı kodun kendisinden değil, problemin gereksinimlerinden gelir. AI bir fonksiyonun gövdesini üretebilir; fakat fonksiyonun hangi girdileri kabul etmesi gerektiğini, boş verinin ne anlama geldiğini veya hatanın kullanıcıya nasıl gösterileceğini sizin belirlemeniz gerekir.

Bu yüzden öğrencinin ilk bakışta çalışan koda otomatik olarak güvenmemesi, AI aracını kötülemek anlamına gelmez. Tam tersine, AI’dan alınan çıktıyı bilinçli biçimde değerlendirmek yazılım geliştirmenin temel sorumluluklarından biridir. Kod üretimini hızlandırabilirsiniz; ancak gereksinimi anlama, sonucu ölçme ve riskli durumları deneme görevini tamamen devretmemelisiniz.

AI Kodları Neden Makul Görünüp Yanlış Olabilir?

Bir AI kod asistanı, kendisine verilen açıklamaya ve bağlama dayanarak olası bir çözüm üretir. Bunu yaparken metinlerde ve kod örneklerinde sık görülen örüntülerden yararlanır, yaygın çözüm biçimlerini bir araya getirir ve eksik bırakılan noktaları makul görünen varsayımlarla tamamlamaya çalışır.

Bu süreç niyet okuma değildir. Kod asistanı, sizin zihninizdeki iş kuralını otomatik olarak bilemez. “Listedeki değerleri topla” ifadesi; yalnızca pozitif sayıları toplamak, boş listeyi sıfır kabul etmek, hatalı değerleri atlamak veya hatalı girdide işlem durdurmak anlamına gelebilir. Bu seçeneklerden hangisinin doğru olduğu, cümlenin teknik ayrıntısından çok uygulamanın amacına bağlıdır.

Makul görünen yanlış kodların birkaç yaygın nedeni vardır:

• Eksik bağlam: Fonksiyonun nerede kullanılacağı, verinin hangi kaynaktan geldiği veya kullanıcı hatalarının mümkün olup olmadığı belirtilmemiş olabilir.
• Yaygın ama dar çözüm: Çözüm, yalnızca normal ve temiz girdiler için hazırlanmış örneklerden etkilenmiş olabilir.
• Varsayımların görünmez kalması: Kod bir veri türünü, belirli bir liste biçimini veya her zaman değer bulunacağını varsayabilir.
• Eski ya da uyumsuz yaklaşım: Genel olarak bilinen bir yöntem, sizin kullandığınız kütüphane, proje yapısı veya gereksinimle tam olarak uyuşmayabilir.
• Başarılı örneğin yanıltması: Tek bir testin geçmesi, diğer girdilerin de doğru işleneceği izlenimi oluşturabilir.

Örneğin bir arama fonksiyonu, aranan değeri bulduğunda doğru konumu döndürüyor olabilir. Peki değer bulunamadığında ne yapıyor? -1 mi döndürüyor, None mı döndürüyor, hata mı oluşturuyor? Çağıran kod bu seçeneklerin yalnızca biriyle uyumluysa, fonksiyon normal örnekte çalışsa bile sistemin başka bir noktasında yanlış davranış ortaya çıkabilir.

Benzer şekilde, negatif sayılar çoğu matematiksel işlem için geçerli olabilir; ancak yaş, ürün adedi veya sınav puanı gibi alanlarda negatif değerler iş kuralına aykırı olabilir. AI’ın ürettiği kod negatif değeri teknik olarak kabul edebilir. Bu durumda sorun Python’ın çalışmasında değil, kabul edilen girdinin tanımlanmamış olmasındadır.

Kodu kullanmadan önce aşağıdaki dört soruyu bir karar çerçevesi olarak uygulayın:

1. Girdi sözleşmesi nedir? Fonksiyon hangi veri türlerini, hangi aralıkları ve hangi zorunlu alanları kabul ediyor?
2. Hangi durumlarda fonksiyon başarısız olabilir? Boş liste, None, negatif sayı, tekrar eden değer, çok büyük sayı veya yanlış veri türü için davranış nedir?
3. Beklenen çıktı nasıl ölçülür? Sonucun yalnızca türü mü önemli, yoksa belirli bir değer, sıralama, hata mesajı veya işlem süresi de mi bekleniyor?
4. Kodun varsayımı nerede yazıyor? Bir davranış önemliyse yalnızca kodun içinde gizli kalmamalı; isimlendirme, açıklama, doğrulama veya test ile görünür hâle getirilmelidir.

Bu çerçeve, “AI doğru mu yazdı?” sorusunu daha uygulanabilir sorulara dönüştürür. Önce girdiyi ve beklenen davranışı tanımladığınızda, ardından normal ve sınır durumlarını denediğinizde kodu değerlendirmek kolaylaşır.

En sağlıklı yaklaşım, AI çıktısını hazır bir hüküm olarak değil, incelenecek bir taslak olarak görmektir. Taslak iyi olabilir, hatta doğrudan çalışabilir; yine de hangi problemi çözdüğünü, hangi problemi çözmediğini ve hangi varsayımlara dayandığını sizin kontrol etmeniz gerekir.

Önce Anla Sonra Kullan: Dört Adımlı Kod Doğrulama Süreci

AI tarafından üretilen bir kodu doğrulamanın en güvenli yolu, doğrudan çalıştırıp çıkan sonuca bakmakla sınırlı değildir. Önce kodun ne yapması gerektiğini kendi cümlelerinle açıklamalı, sonra farklı girdilerle davranışını sınamalı, kodu satır satır manuel olarak izlemeli ve son olarak elde ettiğin sonucu beklenen sonuçla karşılaştırmalısın. Bu yaklaşım, Berk Akademi’nin önce anla sonra kullan felsefesini günlük kod çalışmalarında uygulanabilir bir sürece dönüştürür.

Bu dört adımlı çerçeveyi aşağıdaki örnek üzerinden düşünebilirsin: “Bir listedeki en büyük sayıyı bulan bir fonksiyon yaz.” AI sana kısa ve makul görünen bir çözüm verebilir. Ancak listenin boş olması, girdinin None olması veya negatif sayılardan oluşması gibi durumlarda bu kodun gerçekten beklediğin davranışı gösterip göstermediğini ayrıca kontrol etmen gerekir. Temel bilgini ölçmek ve hangi konularda tekrar yapman gerektiğini görmek için ücretsiz yazılım bilgi testinden de yararlanabilirsin.

1. Fonksiyonun amacını ve girdi-çıktı sözleşmesini kendi cümlelerinle yaz.

   İlk adımda kodu henüz çalıştırmadan, fonksiyonun görevini açıkça ifade et. “Bir listedeki en büyük sayıyı döndürür” demek başlangıç için yeterlidir; fakat daha iyi bir açıklama, hangi girdilerin kabul edildiğini ve sorunlu girdilerde ne olacağını da belirtir.

   • Fonksiyon hangi tür veriyi kabul ediyor?
   • Sonuç olarak ne döndürmesi gerekiyor?
   • Liste boşsa nasıl davranmalı?
   • Girdi hiç verilmezse veya None olursa ne yapmalı?
   • Negatif sayılar geçerli bir girdi mi?

   Örnek sözleşme şöyle yazılabilir: “Fonksiyon, sayılardan oluşan bir liste alır ve listedeki en büyük sayıyı döndürür. Boş liste veya None verilirse bunu açık bir hata mesajıyla bildirir. Negatif sayılar kabul edilir.” Bu açıklama, AI’ın yazdığı kodu değerlendirmek için kullanacağın ölçütü oluşturur.

2. Normal ve sınır durumlarını kapsayan test senaryoları hazırla.

   Tek bir normal örnek, kodun bütün durumlarda doğru olduğunu kanıtlamaz. Test senaryolarını hazırlarken yalnızca beklediğin tipik kullanımı değil, kodun varsayımlarını zorlayacak girdileri de düşünmelisin.

   • Normal liste: [3, 8, 2] → beklenen sonuç: 8
   • Tek elemanlı liste: [5] → beklenen sonuç: 5
   • Boş liste: [] → açık ve kontrollü bir hata beklenir
   • None girdisi → açık ve kontrollü bir hata beklenir
   • Negatif değerler: [-7, -2, -10] → beklenen sonuç: -2

   Kendine şu soruları sor: “Bu test, kodun hangi varsayımını sınlıyor?”, “Sonucun ne olması gerektiğini önceden yazdım mı?” ve “Kodun hata vermesi gerekiyorsa bu hata anlaşılır mı?” Beklenen sonucu testten önce yazmak önemlidir; aksi hâlde programın verdiği her sonucu doğru kabul etme eğilimine girebilirsin.

3. Kodu satır satır dry run ile manuel yürüt.

   Dry run, kodu bilgisayara bırakmadan zihinsel veya yazılı olarak adım adım çalıştırmaktır. Özellikle kısa fonksiyonlarda oldukça etkilidir. Her satırdan sonra değişkenlerin değerini küçük bir tabloya veya madde listesine yazabilirsin.

   Örneğin [3, 8, 2] listesindeki en büyük sayıyı arayan bir döngü olduğunu düşün. Başlangıçta en büyük değer 3 kabul edilir. İlk karşılaştırmada 8, mevcut değerden büyük olduğu için en büyük değer 8 olur. Sonraki değer olan 2, 8’den küçük olduğu için sonuç değişmez.

   Adım	İncelenen değer	Mevcut en büyük değer
   Başlangıç	-	3
   1	8	8
   2	2	8

   Ardından aynı yürütmeyi [] ve None için yap. Boş listede döngüye girecek hiçbir eleman yoktur; kod başlangıç değerini nasıl belirleyeceğini düşünmemişse varsayımı bozulur. None ise üzerinde dolaşılabilecek bir liste değildir. Dolayısıyla kod, “her zaman sayılardan oluşan bir liste gelecek” varsayımına dayanıyorsa bu iki girdide sorun yaşar.

   • Satır çalışmadan önce değişkenin değeri nedir?
   • Koşul doğru mu, yanlış mı?
   • Döngü kaç kez çalışacak?
   • Liste boş olduğunda hangi satır hiç çalışmayacak?
   • None geldiğinde kod hangi işlemi yapmaya çalışıyor?
4. Elde edilen sonucu beklenen sonuçla karşılaştır ve gerekirse kodu düzelt.

   Son adımda programın verdiği sonucu, ikinci adımda önceden yazdığın beklenen sonuçlarla karşılaştır. Normal liste doğru sonuç veriyorsa ama boş liste veya None için belirsiz ya da kontrolsüz hata oluşuyorsa kod tamamen doğrulanmış sayılmaz.

   Burada amaç her hatayı gizlemek değildir. Bazen hata vermek doğru davranıştır; önemli olan hatanın kontrollü, anlaşılır ve sözleşmeye uygun olmasıdır. Örneğin boş liste için ValueError, yanlış türde bir girdi için TypeError kullanılması, sorunun kaynağını anlamayı kolaylaştırabilir.

   Kendine şu soruları sor: “Kod bütün geçerli girdilerde doğru sonuç veriyor mu?”, “Geçersiz veya eksik girdilerde davranış açık mı?”, “Hata mesajı kullanıcıya sorunu düzeltmesi için yeterli bilgi veriyor mu?” Cevaplardan biri hayırsa AI’dan yeni bir kod istemeden önce problemin ne olduğunu kendin tarif et ve mevcut çözümü bu gereksinime göre düzelt.

Aynı Örnek İçin Mini Doğrulama Şablonu

Bir AI kodunu incelerken aşağıdaki kısa şablonu her örneğe uyarlayabilirsin:

• Amaç: Kod tam olarak hangi problemi çözüyor?
• Sözleşme: Hangi girdiler geçerli, çıktı ne olmalı?
• Testler: Normal, boş, None, negatif ve tek elemanlı örneklerde beklenen sonuç ne?
• Dry run: Değişkenler her satırdan sonra hangi değeri alıyor?
• Karşılaştırma: Gerçek çıktı ile beklenen çıktı aynı mı?
• Düzeltme: Sorun sonuçta mı, girdi kontrolünde mi, yoksa kodun varsayımında mı?

Bu şablon, “Kod çalıştı, demek ki tamam” düşüncesini “Kod hangi koşullarda doğru çalışıyor?” sorusuna dönüştürür. Böylece AI’ı yalnızca kod üreten bir araç olarak değil, senin kontrol etmen gereken bir yardımcı olarak kullanırsın.

Python Örneği: Normal Girdide Çalışan Hata Nasıl Yakalanır?

Şimdi bu dört adımı, listedeki en büyük sayıyı bulan kısa bir Python fonksiyonu üzerinde uygulayalım. İlk sürüm normal bir listeyle çalışabilir; ancak boş liste ve None girdisi için gerekli kontrolleri içermez. Bu nedenle yalnızca başarılı bir örneği çalıştırmak, kodun doğru olduğu sonucuna ulaşmak için yeterli değildir.

Eksik AI önerisi

def en_buyuk_deger(sayilar):
    return max(sayilar)

print(en_buyuk_deger([3, 8, 2]))
print(en_buyuk_deger([5]))

Bu kodun normal girdilerde beklenen çıktısı şöyledir:

8
5

[3, 8, 2] için max() listedeki en büyük değeri, yani 8’i döndürür. [5] tek elemanlı olduğu için sonuç doğrudan 5 olur. Bu iki test başarılıdır; fakat henüz boş listeyi veya None girdisini sınamadık.

Dry run sırasında [3, 8, 2] girdisini izlediğimizde fonksiyon listeyi max() işlevine gönderir ve sonuç 8 olur. Ancak [] verildiğinde max() karşılaştırabileceği hiçbir değer bulamaz. Bu durumda fonksiyon sonuç döndürmek yerine ValueError üretir. None verildiğinde ise fonksiyonun elinde üzerinde işlem yapabileceği bir liste yoktur; bu nedenle TypeError oluşur.

• en_buyuk_deger([]) → hata: boş dizide en büyük değer belirlenemez.
• en_buyuk_deger(None) → hata: None üzerinde liste işlemi yapılamaz.
• en_buyuk_deger([-7, -2, -10]) → beklenen sonuç: -2.

Negatif değerler tek başına problem değildir. “En büyük sayı” yalnızca pozitif sayılar anlamına gelmez; -2, -7 ve -10 arasında matematiksel olarak en büyük değerdir. Bu nedenle negatif listeyi reddetmek, gereksinimde böyle bir kısıt yoksa yeni ve gereksiz bir hata olur.

Girdi kontrolü eklenmiş sürüm

def en_buyuk_deger(sayilar):
    if sayilar is None:
        raise TypeError("Girdi None olamaz.")
    if not sayilar:
        raise ValueError("Liste boş olamaz.")
    return max(sayilar)

print(en_buyuk_deger([3, 8, 2]))
print(en_buyuk_deger([5]))
print(en_buyuk_deger([-7, -2, -10]))

Düzeltilmiş sürümün beklenen çıktısı şöyledir:

8
5
-2

Boş liste ve None için fonksiyonu doğrudan yazdırmak yerine hatanın kontrollü biçimde oluştuğunu gözlemlemek gerekir. Örneğin en_buyuk_deger([]) çağrısı “Liste boş olamaz.” mesajıyla ValueError üretir. en_buyuk_deger(None) çağrısı ise “Girdi None olamaz.” mesajıyla TypeError üretir. Buradaki amaç hatayı ortadan kaldırmak değil, fonksiyonun beklenmeyen girdiyi anlaşılır biçimde yönetmesini sağlamaktır.

Bu örnekte doğrulama adımlarını şöyle uygulayabilirsin:

1. Fonksiyonun amacını yaz: Sayı listesindeki en büyük değeri döndürecek.
2. Testleri belirle: Normal liste, tek elemanlı liste, boş liste, None ve negatif değerler.
3. Dry run yap: [3, 8, 2] için sonucun 8, negatif liste için -2 olması gerektiğini elle izle.
4. Karşılaştır: Gerçek sonuçları beklenen sonuçlarla kontrol et; boş ve None girdilerinde açık hata davranışını doğrula.

Burada dikkat edilmesi gereken nokta, düzeltilmiş kodun yalnızca “daha uzun” olması değildir. Asıl fark, kodun hangi girdileri kabul ettiğinin ve hangi durumlarda nasıl davranacağının açık hâle gelmesidir. Python öğrenirken bu tür küçük örneklerde girdi kontrolü, hata ayıklama ve dry run alışkanlığı kazanmak; daha sonra fonksiyonlar, sınıflar ve daha büyük projelerde kod incelemeyi kolaylaştırır. Bu konuları uygulamalı ve kişiselleştirilmiş biçimde ilerletmek isteyenler için birebir Python dersleri de uygun bir çalışma yolu olabilir.

Kod Kontrol Listesi: Kullanımdan Önce Kendine Ne Sormalısın?

AI tarafından üretilen bir kodu kullanmadan önce onu yalnızca çalıştırmak yeterli değildir. Kodun ne yaptığını anlamalı, hangi girdilerde nasıl davranacağını düşünmeli ve hem başarılı hem de başarısız senaryoları denemelisin. Aşağıdaki “kullanmadan önce doğrula” kartı, kopyala-yapıştır kullanımını azaltmak için her kod parçasından sonra uygulanabilir.

1. Kodun ne yaptığını açıklayabiliyor muyum?
   • Her satırın veya önemli kod bloğunun görevini kendi cümlelerimle anlatabiliyor muyum?
   • Değişkenlerin hangi bilgiyi tuttuğunu biliyor muyum?
   • Döngünün kaç kez çalışacağını, koşulun ne zaman doğru veya yanlış olacağını tahmin edebiliyor muyum?
   • Bir fonksiyon varsa aldığı girdiyi nasıl işlediğini ve ne döndürdüğünü açıklayabiliyor muyum?

   Bir satırı açıklayamıyorsan bu mutlaka kodun yanlış olduğu anlamına gelmez; ancak henüz güvenle kullanıma hazır olmadığını gösterir. Önce anlamadığın bölümü küçült, değişken adlarını sadeleştir veya AI aracından aynı kodu daha basit biçimde açıklamasını iste.

2. Girdi türleri ve beklenen çıktı açık mı?
   • Fonksiyon sayı mı, metin mi, liste mi yoksa başka bir veri türü mü bekliyor?
   • Girdi boş bırakılırsa ne olması gerekiyor?
   • Fonksiyon bir değer mi döndürüyor, ekrana yazdırıyor mu, yoksa hata mı oluşturuyor?
   • Beklenen çıktı için küçük ve net bir örnek hazırladım mı?

   Örneğin bir fonksiyonun listedeki en büyük sayıyı bulması bekleniyorsa [3, 8, 2] girdisi için beklenen sonucun 8 olduğunu önceden bilmelisin. Beklenen sonucu tanımlamadan yapılan test, yalnızca kodun ekrana bir şey yazıp yazmadığını kontrol eder.

3. Normal girdinin dışındaki durumları denedim mi?

   AI tarafından üretilen kodlar çoğu zaman örnek olarak verilen “ideal” veri üzerinde makul görünebilir. Oysa gerçek kullanımda veri eksik, boş, negatif veya beklenmeyen biçimde gelebilir. En azından şu girdileri düşün:

   • Boş liste: []
   • None değeri
   • Sıfır: 0
   • Negatif sayılar
   • Tek elemanlı liste veya tek değer
   • Tekrarlanan değerler
   • Beklenmeyen veri türü
   • Çok büyük veya çok uzun bir girdi

   Her durum için aynı sonucu beklemek gerekmez. Önemli olan, kodun davranışının bilinçli olmasıdır. Örneğin boş bir listede anlamlı bir mesaj döndürmek, kontrolsüz bir IndexError almaktan daha anlaşılır olabilir.

4. Hata mesajı veya dönüş değeri anlaşılır mı?
   • Hata oluştuğunda mesaj, sorunun hangi girdiden veya işlemden kaynaklandığını anlatıyor mu?
   • Fonksiyon başarısız durumda None, False veya özel bir hata mı döndürüyor?
   • Bu davranış, kodu çağıran bölüm tarafından doğru şekilde ele alınıyor mu?

   Bir programın hiç hata vermemesi her zaman iyi tasarlandığı anlamına gelmez. Bazen hatayı bastıran bir try-except bloğu, gerçek sorunu gizleyebilir. Hata yönetimi, problemi sessizce saklamak yerine sorunu anlamayı ve doğru tepki vermeyi kolaylaştırmalıdır.

5. Kodun varsayımları nerede?

   Her kod bazı kabullere dayanır. Örneğin bir fonksiyon, listedeki tüm elemanların sayı olduğunu, metnin boş olmadığını veya dosyanın belirli bir klasörde bulunduğunu varsayabilir. Bu varsayımlar kodun içinde açıkça görülmüyorsa kendine şu soruları sor:

   • Bu veri her zaman beklediğim biçimde mi gelecek?
   • Eksik veya hatalı veri geldiğinde ne olacak?
   • Kod, yalnızca örnekteki değerlerle mi çalışıyor?
   • Fonksiyonun kullanımı için ön koşullar var mı?
6. Aynı problemi küçük bir örnekle elle çözdüm mü?

   Dry run, kodu çalıştırmadan önce adımları sırayla takip etmektir. Küçük bir veri seçerek değişkenlerin her adımda aldığı değeri yaz. Örneğin [4, 1, 7] listesinin toplamını bulan bir döngüde toplam değişkeninin sırasıyla 0, 4, 5 ve 12 olmasını beklersin. Kodun ürettiği sonuç bu elle yaptığın işlemle eşleşmiyorsa, program çalışsa bile mantıkta sorun olabilir.

7. Başarısızlık durumlarını da test ettim mi?

   Yalnızca “doğru sonucu verdi” testleri yeterli değildir. Kodun yanlış veya eksik girdiler karşısındaki davranışını da kontrol et. Bir dosya bulunamadığında, kullanıcı sayı yerine metin girdiğinde, liste boş olduğunda veya aranan değer mevcut olmadığında program ne yapıyor?

   İyi bir doğrulama süreci, başarısızlığı ortadan kaldırmaya değil, başarısızlık gerçekleştiğinde davranışı öngörülebilir hâle getirmeye çalışır.

Hızlı doğrulama kartı

• Ne yaptığını satır satır açıklayabiliyor muyum?
• Girdi türü, beklenen çıktı ve hata davranışı belli mi?
• Boş liste, None, sıfır, negatif değer ve tek eleman denendi mi?
• Beklenmeyen veri türü veya eksik veri geldiğinde ne olacağını biliyor muyum?
• Kodun varsayımlarını açıkça görebiliyor muyum?
• Küçük bir örneği elle çözüp sonucu kodla karşılaştırdım mı?
• Yalnızca olumlu sonuçları değil, başarısızlık senaryolarını da test ettim mi?
• Hata mesajı, dönüş değeri ve kullanıcıya verilen açıklama anlaşılır mı?

Python temellerini sistemli biçimde çalışmak ve bu soruları yalnızca AI kodlarında değil, kendi yazdığın örneklerde de uygulamak istiyorsan 1-1 özel Python eğitimi içinde kodu önce anlayıp sonra kullanmaya dayalı bir çalışma düzeni oluşturabilirsin. Buradaki amaç hazır kodu ezberlemek değil, her satırın sorumluluğunu kavrayarak ilerlemektir.

Bu kontrol listesi yalnızca yapay zeka araçlarının ürettiği kodlar için geçerli değildir. Başkasının yazdığı, geçmişten kalan veya daha önce kendin oluşturduğun bir kodu çalıştırırken de aynı disipline ihtiyaç duyarsın. Yazılım geliştirmede güven, kodun kim tarafından yazıldığından değil; ne yaptığı, hangi koşullarda çalıştığı ve sınır durumlarında nasıl davrandığı doğrulandığında oluşur.

Sık Sorulan Sorular

AI tarafından yazılan kodu kullanmadan önce ilk olarak neyi kontrol etmeliyim?

İlk olarak kodun ne yaptığını ve hangi girdiyi beklediğini kontrol etmelisin. Kodun her satırını ezberlemen gerekmez; ancak ana akışı, değişkenlerin görevini, fonksiyonun dönüş değerini ve olası hata noktalarını açıklayabilmelisin. Açıklayamadığın bir kodu doğrudan kullanmak yerine önce küçük bir örnek üzerinde incelemek daha güvenlidir.

Bir kod hata vermeden çalışıyorsa neden yine de yanlış olabilir?

Çünkü programlama dilinin kurallarına uygun çalışan bir kod, problemin gerektirdiği doğru sonucu üretmeyebilir. Örneğin yanlış bir koşul ifadesi sözdizimi hatası oluşturmayabilir; fakat bazı girdileri hatalı sınıflandırabilir. Bu nedenle kodun yalnızca çalışıp çalışmadığını değil, beklenen sonuçları verip vermediğini ve farklı girdilerde mantıklı davrandığını da test etmelisin.

Boş liste ve None gibi sınır durumları neden özellikle test edilmelidir?

Bu değerler, normal girdilerde görünmeyen varsayımları ortaya çıkarır. Kod listenin en az bir elemanı olduğunu veya her zaman bir nesne geleceğini varsayıyorsa boş liste ya da None karşısında hata verebilir. Sınır durumlarını test etmek, kodun yalnızca ideal örneklerde değil, gerçek kullanımda karşılaşabileceği eksik ve beklenmeyen verilerde de nasıl davranacağını görmeni sağlar.

Dry run yöntemi AI tarafından üretilen kodun hatasını bulmaya nasıl yardımcı olur?

Dry run sırasında kodu çalıştırmadan, seçtiğin küçük girdiyi adım adım takip edersin. Her döngüde değişkenlerin değerini, koşulların sonucunu ve fonksiyonun hangi noktada ilerlediğini yazarsın. Böylece kodun ürettiği sonuç ile problemi elle çözdüğünde ulaştığın sonucu karşılaştırabilirsin. İki sonuç eşleşmiyorsa hata genellikle koşulda, başlangıç değerinde, döngü sınırında veya verinin işlenme sırasındadır.

AI ile kod yazarken en sağlam alışkanlık, kodu hemen kullanmak yerine önce anlamak, küçük bir örnekle denemek ve farklı sonuçları bilinçli biçimde kontrol etmektir.