Programlamaya Giriş

4.1Temel kavramlar

Bir yemek tarifi, mutfakta ne yapılacağını adım adım anlatır. Tarifi okuyan kişi “bir tutam tuz” gibi belirsiz bir ifadeyi kendi deneyimiyle tamamlar. Bilgisayarın böyle bir deneyimi yoktur. Ona verilen her adımın tek bir anlamı olmalı ve bu anlam önceden kesin olarak tanımlanmış olmalıdır. Programlama dilleri bu ihtiyaçtan doğdu.

4.1.1Programlama dili nedir?

Gündelik dil esnektir. “Yarın görüşürüz” cümlesinin saati belli değildir; dinleyen kişi bağlama bakarak anlamı tamamlar. Bir makinenin bağlamdan anlam çıkarması beklenemez. Makineye iş yaptırmak için her ifadenin tek bir yorumu olan, kuralları önceden yazılmış bir dil gerekir. Böyle dillere biçimsel dil denir.

Programlama dili bir algoritmayı bilgisayarın yürütebileceği biçimde yazmanın aracıdır. Algoritma bir fikirdir: “a ile b'yi topla, sonucu yaz.” Bu fikir Java'da, Python'da ya da C'de yazılabilir. Yazılışlar birbirinden farklıdır ama hepsi aynı adımları anlatır ve aynı girdi için aynı çıktıyı üretir. Şekil 4.1 bunu a = 3 ve b = 5 için gösterir: üç dilde de ekrana 8 yazılır.

Şekildeki satırlar tam programların yalnızca toplama kısmıdır. Bir programın çalışabilmesi için bunların çevresinde başka satırlar da gerekir. Aşağıda aynı işin Java ve C'deki tam hâli görülüyor. Java programı JDK 21 ile derlenip çalıştırılmıştır; C programı için çıktı satır satır izlenerek belirlenmiştir.

public class Topla {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;
        System.out.println(a + b);
    }
}

#include <stdio.h>

int main(void) {
    int a = 3;
    int b = 5;
    printf("%d\n", a + b);
    return 0;
}

8

Aynı problemin farklı dillerle çözülebilmesi bir seçim sorusu doğurur: hangi dil? Cevap problemin ihtiyaçlarına ve programın çalışacağı ortama bağlıdır. Bir telefonda çalışacak uygulama, bir sunucuda çalışacak hesap ve bir çamaşır makinesinin denetim yazılımı farklı dilleri gerektirebilir.

4.1.2Söz dizimi ve anlam

Türkçede “Ali okula gitti” cümlesi doğru kurulmuştur. “Gitti okula Ali” cümlesi de anlaşılır ama kurallı değildir. “Okul Ali'ye gitti” ise kurallıdır ama anlamsızdır. Programlama dillerinde de bu iki boyut ayrı ayrı tanımlanır: bir yazılışın kurala uygun olup olmadığı ve kurala uygun bir yazılışın ne yaptığı.

Java'da her deyimin noktalı virgülle bitmesi bir söz dizimi kuralıdır. int b = 5 satırının sonunda noktalı virgül yoksa yazılış kurala aykırıdır ve program çevrilemez. a + b ifadesinin a ile b'nin toplamını hesaplaması ise anlam kuralıdır. Python'da söz dizimi farklıdır: deyim sonunda noktalı virgül gerekmez, ama blokların girintisi kuralın parçasıdır.

Söz dizimi doğru olan her program istenen sonucu vermez. Üç notun ortalamasını hesaplarken toplamı 3 yerine 4'e bölen bir satır kurala tamamen uygundur. Çeviri aracı bu satırı sorunsuz kabul eder, program çalışır ve yanlış bir sayı yazar. Yazılış doğrudur ama yazılan şey, programcının istediği şey değildir. Böyle hatalara mantık hatası denir.

4.1.3Kaynak kod, assembly ve makine dili

Programcının yazdığı metin bir metin dosyasında durur. Bu dosya Not Defteri ile açılıp okunabilir, değiştirilebilir. İşlemci ise bu metni okuyamaz. İşlemcinin anladığı komutlar ikili sayılarla kodlanmıştır ve her işlemci ailesinin kendi komut kümesi vardır.

Şekil 4.2 tek bir satırın bu üç biçimden nasıl geçtiğini gösterir. Derleyici, kaynak koddaki toplam = a + b; satırını üç işlemci komutuna çevirir. İlk komut a'nın değerini bellekten işlemcinin bir yazmacına (R1) yükler. İkincisi b'yi R1'e ekler. Üçüncüsü R1'deki sonucu bellekte toplam'ın yerine yazar. Assembly bu komutları LOAD, ADD ve STORE gibi kısa adlarla yazar. Assembler adı verilen bir araç da bu adları ikili kodlara çevirir. Şekildeki ikili kodlar yalnızca bir örnektir; gerçek kodlama işlemciden işlemciye değişir.

Bu çeviriden iki sonuç çıkar. Birincisi, programlama dili ile işlemci dili aynı şey değildir. Java ya da Python bir işlemcinin dili değildir; bu dillerle yazılmış metnin işlemciye ulaşması için bir çeviri gerekir. Bu çeviriyi yapan programlara genel olarak çeviri aracı denir: derleyici ve yorumlayıcı. İkincisi, yüksek seviyeli bir satır çoğu zaman birden fazla makine komutuna karşılık gelir. Programcı “topla ve sakla” der; yükleme, toplama ve yazma adımlarını çeviri aracı ayrıntılandırır.

4.2Programın çalıştırılması

Kaynak kod yazıldıktan sonra ekranda bir sonuç görünene kadar birkaç iş yapılır. Metin bir çeviri aracından geçer, çevrilen kod işlemcide ya da bir sanal makinede çalışır, çalışan program girdisini okuyup çıktısını üretir. Bu yolun her durağında farklı türden bir hata ortaya çıkabilir.

4.2.1Kaynak koddan çıktıya

Şekil 4.3 bir Java programının yolunu beş durakta gösterir. Programcı kaynak kodu Topla.java adlı bir metin dosyasına yazar. Bilgisayar bu metni olduğu gibi çalıştıramaz. Çeviri durağında derleyici metni okur ve dilin kurallarına uyup uymadığını denetler. Hata yoksa bir çıktı dosyası üretir. C gibi dillerde bu dosya doğrudan makine kodudur. Java'da ise Topla.class adlı bir ara kod dosyasıdır. Çalıştırma durağında komutlar işlemcide yürütülür; Java'da bu iş Java Sanal Makinesi (JVM, Java Virtual Machine) üzerinden yapılır. Son durakta program çıktısını üretir: a = 3 ve b = 5 için 8.

Java'da bu yol komut satırında iki komutla yürünür. javac Topla.java derleyiciyi çalıştırır ve Topla.class dosyasını üretir. java Topla ise JVM'yi başlatır ve bu dosyadaki programı çalıştırır. İki adımın ayrı olması önemlidir: derleme bir kez yapılır, üretilen dosya istendiği kadar çalıştırılabilir. Kaynak kodda bir değişiklik yapılırsa derlemenin yinelenmesi gerekir; yoksa JVM eski .class dosyasını çalıştırmaya devam eder.

4.2.2Hata türleri

Hat üzerindeki her durak, kendine özgü bir hata türünü ortaya çıkarır. Bir hatanın hangi durakta göründüğünü bilmek, onu nerede arayacağımızı da söyler.

Üç türü birer küçük Java programıyla görmek kolaydır. İlk programda ikinci atama satırının sonundaki noktalı virgül unutulmuştur:

public class NoktaliVirgul {
    public static void main(String[] args) {
        int a = 3;
        int b = 5
        System.out.println(a + b);
    }
}

Derleyici programı çevirmeyi reddeder ve hatanın yerini satır numarasıyla bildirir:

NoktaliVirgul.java:4: error: ';' expected
        int b = 5
                 ^
1 error

İleti dosya adını, satır numarasını (4) ve beklenen işareti (;) söyler. Alttaki ^ işareti, derleyicinin noktalı virgülü nerede beklediğini gösterir. Bu durumda .class dosyası üretilmez ve programın hiçbir satırı çalışmaz; ekranda “8” görünmez. Şekil 4.4 bu durumu hattın çeviri durağındaki kırmızı işaretle gösterir.

İkinci programda söz dizimi kusursuzdur ama üçüncü satırda sıfıra bölme vardır:

public class SifiraBolme {
    public static void main(String[] args) {
        System.out.println("Merhaba");
        int x = 10;
        System.out.println(x / 0);
        System.out.println("Son");
    }
}

Derleme başarıyla biter. Program çalışınca önce “Merhaba” yazılır, sonra x / 0 hesaplanmaya çalışılır ve JVM programı durdurur:

Merhaba
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at SifiraBolme.main(SifiraBolme.java:5)

Çıktıdaki ArithmeticException: / by zero sıfıra bölme hatasını, SifiraBolme.java:5 de hatanın kaynak dosyadaki satırını gösterir. “Son” satırı hiç çalışmaz. Derleyici bu hatayı yakalayamaz, çünkü x'in değeri ve bölme işlemi ancak çalışma sırasında hesaplanır. Bölen bir kullanıcı girdisi olsaydı, sıfır olup olmayacağını derleme sırasında bilmek zaten imkânsız olurdu.

Üçüncü program üç notun ortalamasını hesaplar ama bir parantez eksiktir:

public class OrtalamaHata {
    public static void main(String[] args) {
        int n1 = 70, n2 = 85, n3 = 90;
        System.out.println(n1 + n2 + n3 / 3);
        System.out.println((n1 + n2 + n3) / 3);
        System.out.println((n1 + n2 + n3) / 3.0);
    }
}

185
81
81.66666666666667

Program sorunsuz derlenir, hiçbir hata iletisi vermeden çalışır ve ilk satırda 185 yazar. Beklenen sonuç 81 ile 82 arasında bir sayıdır. Bölme toplamadan önce yapıldığı için yalnızca n3 üçe bölünmüştür: 70 + 85 + 90 / 3 = 70 + 85 + 30 = 185. Bu bir mantık hatasıdır. İkinci satır parantezi ekler ama yine tam doğru değildir. Java'da iki tam sayının bölümü tam sayıdır; 245 / 3 işleminin kesirli kısmı atılır ve sonuç 81 olur. Üçüncü satır 3.0 ile böler; işlem ondalıklı yapılır ve doğru değer, yaklaşık 81,67 çıkar. Mantık hatalarının ortak özelliği budur: program “çalışır”, sorunu ancak beklenen sonuçla gerçek sonucu karşılaştıran biri fark eder.

4.2.3Derlenen, yorumlanan ve hibrit diller

Kaynak kodu çalıştırmanın üç yaygın yolu vardır. Fark, çevirinin ne zaman ve ne kadarının yapıldığındadır.

Şekil 4.5 üç yolu yan yana gösterir. Derlenen yolda kaynak.c dosyası derleyiciden geçer ve program.exe gibi bir çalıştırılabilir dosya çıkar. Bu dosya işlemcide doğrudan çalışır; çalıştırma anında derleyiciye artık gerek yoktur. Yorumlanan yolda kaynak.py dosyası her çalıştırmada yorumlayıcıya verilir. Yorumlayıcı komutları sırayla işler ve işlemciye yaptırır. Ortada kalıcı bir makine kodu dosyası yoktur. Hibrit yolda Topla.java önce javac ile Topla.class dosyasına derlenir. Bu dosyayı JVM çalıştırır, JVM'nin kendisi de işlemcide çalışan bir programdır.

Hangi yolun seçildiği programın nasıl dağıtılacağını da belirler. Derlenmiş bir C programı yalnızca derlendiği işlemci ve işletim sistemi için geçerlidir. Windows için derlenmiş bir .exe dosyası Linux'ta ya da farklı işlemcili bir bilgisayarda çalışmaz. Yorumlanan bir Python programı kaynak kod olarak dağıtılır; Python yorumlayıcısı kurulu her bilgisayarda çalışır. Java'nın .class dosyası ise işlemciden bağımsızdır: aynı dosya, JVM kurulu her platformda çalışır. Java'nın bilinen “bir kez yaz, her yerde çalıştır” sloganı bu özellikten gelir.

4.2.4Derleyici ve yorumlayıcı adım adım

Derleyici ile yorumlayıcının farkı en iyi aynı küçük program üzerinde görülür. Aşağıdaki üç satırlık sözde kodun üçüncü satırında sıfıra bölme vardır:

Sözde kodda atama ← ile gösterilir: x ← 10, “x'e 10 değerini ver” demektir. Böylece atama, eşitlik karşılaştırmasıyla karışmaz. Program önce bir derleyiciyle, sonra satır satır çalışan basit bir yorumlayıcıyla işlensin. Her adımda olanlar Tablo 4.3 içinde sıralanmıştır.

Bu programda iki yol aynı ekranla biter: “Merhaba” ve ardından hata. Fark, hatanın türünde değil, işin sırasındadır. Derleyici önce bütün metni çevirir, çalıştırma ayrı bir aşama olarak sonra gelir. Yorumlayıcı çevirme ile çalıştırmayı satır satır iç içe yürütür. Sıfıra bölme çalışma zamanı hatası olduğu için iki yolda da ancak üçüncü satır çalışırken görünür. Şekil 4.6 iki yolun son durumunu gösterir.

Hata bir söz dizimi hatası olduğunda iki yol birbirinden ayrılır. Üçüncü satırda bir parantez kapanmamış olsun: yaz (x + 2. Derleyici çeviri sırasında bu satıra takılır ve hiçbir çalıştırılabilir dosya üretmez. Ekranda yalnızca “satır 3: söz dizimi hatası” iletisi görünür; “Merhaba” bile yazılmaz. Satır satır çalışan basit bir yorumlayıcı ise satır 1'i çalıştırıp “Merhaba” yazar, satır 2'de x'e 10 atar ve ancak satır 3'e gelince hatayı fark eder.

Python ve JavaScript gibi bugünkü yorumlayıcılar bu basit modelden biraz ayrılır: çalıştırmaya başlamadan önce dosyanın tamamını ayrıştırırlar. Bu yüzden söz dizimi hatasını en başta bildirirler. Aşağıdaki Python dosyası bunu gösterir:

print("Merhaba")
x = 10
print((x + 2)
print("Son")

  File "sozdizimi.py", line 3
    print((x + 2)
         ^
SyntaxError: '(' was never closed

Ekranda “Merhaba” yoktur. Python, birinci satırı çalıştırmadan önce dosyanın tamamını okumuş ve üçüncü satırdaki kapanmamış parantezi bulmuştur. Aynı dosyada söz dizimi hatası yerine sıfıra bölme olduğunda durum değişir:

print("Merhaba")
x = 10
print(x / 0)
print("Son")

Merhaba
Traceback (most recent call last):
  File "sifira.py", line 3, in <module>
    print(x / 0)
          ~~^~~
ZeroDivisionError: division by zero

Bu kez “Merhaba” yazılmıştır, çünkü sıfıra bölme ancak üçüncü satır çalışırken anlaşılır. Python'un iletisi Java'nınkine benzer: dosya adı, satır numarası, hata türü (ZeroDivisionError) ve kısa açıklama.

4.2.5Bytecode, sanal makine ve JIT

Python'a “yorumlanan dil” denir, ama Python yorumlayıcısının içinde de bir derleme adımı vardır. Python'un en yaygın uygulaması olan CPython, kaynak kodu önce bytecode adı verilen bir ara koda derler. Sonra bu bytecode'u kendi içindeki bir sanal makinede komut komut yürütür. Ortaya bir makine kodu dosyası çıkmaz. Derleme adımı programcıdan gizlidir: python dosya.py komutu iki aşamayı art arda yapar.

Python'un ürettiği bytecode, dis modülüyle görülebilir. Aşağıdaki program alan = en * boy + 2 satırını derler ve bytecode'unu yazdırır:

import dis
dis.dis(compile("alan = en * boy + 2", "<kod>", "exec"))

  0           RESUME                   0

  1           LOAD_NAME                0 (en)
              LOAD_NAME                1 (boy)
              BINARY_OP                5 (*)
              LOAD_CONST               0 (2)
              BINARY_OP                0 (+)
              STORE_NAME               2 (alan)
              RETURN_CONST             1 (None)

Çıktıdaki her satır bir sanal makine komutudur. LOAD_NAME bir değişkenin değerini sanal makinenin yığınına koyar. BINARY_OP 5 (*) yığının üstündeki iki değeri çarpar, LOAD_CONST 2 sabitini yığına ekler, BINARY_OP 0 (+) toplar. STORE_NAME de sonucu alan adına bağlar. Komut adları Python sürümüne göre biraz değişebilir; burada Python 3.13 kullanılmıştır. Sıralama ise her sürümde aynıdır: önce en ile boy çarpılır, sonra 2 eklenir. Bu sıra işlem önceliğinden gelir.

Bytecode'u komut komut yürütmek, makine kodunu doğrudan çalıştırmaktan yavaştır. Her komut için sanal makinenin “bu komut ne demek?” sorusunu yanıtlaması gerekir. Bu yavaşlığı azaltmanın yolu JIT derlemedir.

Şekil 4.7 bu fikri JavaScript üzerinden gösterir. Chrome tarayıcısındaki V8 motoru kodu önce yorumlar. Bir fonksiyonun binlerce kez çağrıldığını görünce onu makine koduna derler. JVM de aynı yolu izler: bytecode önce yorumlanır, sık çalışan metotlar JIT ile makine koduna çevrilir. Bu yüzden uzun süre çalışan Java programları, derlenmiş C programlarına yakın hızlara ulaşabilir.

Bu örnekler önemli bir noktayı ortaya koyar: “derlenen” ya da “yorumlanan” bir dilin değil, o dilin uygulamasının özelliğidir. Python için makine koduna derleyen uygulamalar da yazılmıştır, C için yorumlayıcılar da. Gerçek sistemlerin çoğu iki yöntemi birleştirir. Bir dile “yorumlanan” demek, o dilin en yaygın uygulamasının nasıl çalıştığını söylemenin kısa yoludur.

4.2.6Derleyicinin aşamaları

Derleyici tek bir büyük adımda çalışmaz. İşini birbirini izleyen beş aşamaya böler; her aşamanın çıktısı bir sonrakinin girdisidir. Aşamaları tek bir satır üzerinde izlemek, derleyicinin hangi hatayı nerede yakaladığını da açıklar. İzlenecek satır şudur:

alan = en * boy + 2;

1. Sözcük çözümleme (lexical analysis). Derleyici satırı bir karakter dizisi olarak görür: a, l, a, n, boşluk, = … İlk aşama bu karakterleri anlamlı parçalara ayırır. Bu parçalara belirteç (token) denir. Boşluklar ve açıklamalar bu aşamada atılır. Örnek satırdan sekiz belirteç çıkar ve her birinin türü bellidir (Şekil 4.8).

Bu aşamada yakalanan hatalar, dilde hiçbir belirtece uymayan karakter dizileridir. Java'da # karakteri bir operatör değildir. Kapanmamış bir dizgi de belirtece dönüştürülemez. JDK 21'in derleyicisi bu iki durumu şöyle bildirir:

GecersizKarakter.java:4: error: illegal character: '#'
        int alan = en # boy;
                      ^
GecersizKarakter.java:4: error: not a statement
        int alan = en # boy;
                        ^
2 errors

KapanmamisDizgi.java:3: error: unclosed string literal
        System.out.println("Merhaba);
                           ^
1 error

2. Söz dizimi çözümleme (parsing, syntax analysis). Belirteçler dilin kurallarına göre bir ağaca dizilir; bu ağaca söz dizimi ağacı (syntax tree) denir. Şekil 4.9 örnek satırın ağacını gösterir. Kökte atama (=) vardır; sol kolu alan, sağ kolu en * boy + 2 ifadesidir. Çarpma ağacın daha derinindedir, bu yüzden önce hesaplanır. İşlem önceliği bu ağacın biçimine böylece yerleşir.

Eksik noktalı virgül, kapanmamış parantez ve yanlış sırada yazılmış belirteçler bu aşamada yakalanır. Örneğin int 2x = 5; satırında sözcük çözümleme bir sorun görmez: 2 bir sayı, x bir tanımlayıcıdır. Ama int belirtecinden sonra bir sayının gelmesi kurala aykırıdır. Bu yüzden derleyici hatayı söz dizimi aşamasında bildirir:

GecersizSozcuk.java:3: error: not a statement
        int 2x = 5;
        ^
GecersizSozcuk.java:3: error: ';' expected
        int 2x = 5;
           ^
2 errors

3. Anlam çözümleme (semantic analysis). Söz dizimi doğru olan bir ağacın anlamlı olup olmadığı denetlenir. Kullanılan her adın daha önce bildirilmiş olması gerekir. İşlenenlerin tipleri de birbirine uymalıdır. Örnek satırda en ve boy int olarak bildirilmiştir; int × int + int ifadesi int verir ve int tipindeki alan'a atanabilir (Şekil 4.10).

boy değişkeni bildirilmeden kullanılırsa javac şu iletiyi verir:

public class Tanimsiz {
    public static void main(String[] args) {
        int en = 3;
        int alan = en * boy + 2;
    }
}

Tanimsiz.java:4: error: cannot find symbol
        int alan = en * boy + 2;
                        ^
  symbol:   variable boy
  location: class Tanimsiz
1 error

İleti, bulunamayan simgenin bir değişken olduğunu ve adının boy olduğunu söyler. Tip uyuşmazlığı da bu aşamanın işidir. int tipindeki bir değişkene metin atamak söz dizimi açısından kusursuzdur, ama anlam açısından geçersizdir:

public class TipHatasi {
    public static void main(String[] args) {
        int x = 5;
        x = "beş";
    }
}

TipHatasi.java:4: error: incompatible types: String cannot be converted to int
        x = "beş";
            ^
1 error

İleti “String tipi int'e dönüştürülemez” demektir. Derleyici hatayı, program hiç çalışmadan, 4. satırdaki "beş" değerinin altında gösterir.

4. Ara kod üretimi ve iyileştirme (intermediate code, code optimization). Denetimden geçen ağaç, her biri tek bir işlem yapan basit komutlara dönüştürülür. Bu biçime üç adresli kod denir, çünkü her komutta en fazla üç ad bulunur:

t1 = en * boy
t2 = t1 + 2
alan = t2

Burada t1 ve t2 derleyicinin uydurduğu geçici adlardır. Bu biçim üzerinde kod iyileştirme yapılır: gereksiz işlemler atılır, sonucu derleme sırasında bilinen işlemler önceden hesaplanır. en = 3 ve boy = 4 değişmeyen sabitlerse, 3 × 4 + 2 = 14 hesabı program çalışmadan yapılır ve kodda yalnızca alan = 14 kalır. Bu iyileştirmeye sabit katlama (constant folding) denir (Şekil 4.11).

5. Kod üretimi (code generation). Son aşamada hedef işlemcinin komutları seçilir ve ikili koda çevrilir. Örnek satır için bir işlemcide LOAD, MUL, ADD ve STORE komutları üretilir (Şekil 4.12). Java derleyicisinin hedefi gerçek bir işlemci değil, JVM'dir. Bu yüzden javac makine komutları yerine bytecode üretir.

public class AlanIfade {
    public static void main(String[] args) {
        int en = 3;
        int boy = 4;
        int alan = en * boy + 2;
        System.out.println(alan);
    }
}

public static void main(java.lang.String[]);
    Code:
       0: iconst_3
       1: istore_1
       2: iconst_4
       3: istore_2
       4: iload_1
       5: iload_2
       6: imul
       7: iconst_2
       8: iadd
       9: istore_3
      10: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      13: iload_3
      14: invokevirtual #13                 // Method java/io/PrintStream.println:(I)V
      17: return
}

public class SabitKatlama {
    public static void main(String[] args) {
        final int en = 3;
        final int boy = 4;
        int alan = en * boy + 2;
        System.out.println(alan);
    }
}

public static void main(java.lang.String[]);
    Code:
       0: bipush        14
       2: istore_1
       3: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: iload_1
       7: invokevirtual #13                 // Method java/io/PrintStream.println:(I)V
      10: return
}

İlk üç aşama hata arar ve bulduğu hatayı satır numarasıyla bildirir. Son iki aşama çalışacak kodu üretir. Sıfıra bölme gibi değere bağlı hatalar hiçbir aşamada görünmez, çünkü derleyici programı çalıştırmaz; yalnızca metnine bakar.

4.2.7Bağlayıcı ve yükleyici

Gerçek programlar tek bir dosyadan oluşmaz. Bir hesap makinesi programında kullanıcı arayüzü bir dosyada, hesap fonksiyonları başka bir dosyada durabilir. Programın ekrana yazması, dosya açması ya da karekök alması için ayrıca hazır kütüphane kodu kullanılır. Derleyici her kaynak dosyayı ayrı ayrı çevirir. Bu parçaların tek bir programda birleşmesi ve çalışmak üzere belleğe alınması iki ayrı aracın işidir.

Şekil 4.13 bir C programının yolunu gösterir. main.c ana programı, hesap.c hesap fonksiyonlarını içerir. Derleyici bunları main.o ve hesap.o nesne dosyalarına çevirir. main.o içinde hesap.c'deki bir fonksiyona yapılan çağrı vardır, ama bu fonksiyonun adresi henüz bilinmez. Derleyici yalnızca “burada adı şu olan bir fonksiyon çağrılıyor” notunu bırakır. Bağlayıcı bu notları çözer. Çağrılan fonksiyonu hesap.o'da, printf gibi hazır fonksiyonları kütüphanede bulur. Her çağrıyı doğru adrese bağlar ve sonunda program.exe dosyasını yazar.

Çağrılan bir fonksiyon hiçbir parçada bulunamazsa bağlayıcı bağlama hatası (linking error) verir. Bu hata derleme hatasından farklıdır. Her dosya tek başına kusursuz derlenmiş olabilir; eksik olan, parçalar arasındaki bağdır. Örneğin main.c'de çağrılan ortalama fonksiyonu hesap.c'de ortalma diye yanlış yazılmışsa iki dosya ayrı ayrı derlenir, ama bağlayıcı ortalama adını hiçbir yerde bulamaz.

Program çift tıklandığında ya da komut satırından çağrıldığında yükleyici devreye girer. Dosyayı diskten belleğe kopyalar. Programın ihtiyaç duyduğu paylaşılan kütüphaneleri de yükleyip bağlar: Windows'ta .dll, Linux'ta .so dosyaları. Son olarak işlemciyi programın ilk komutuna yönlendirir. Paylaşılan bir kütüphaneyi birçok program ortak kullanır; aynı kodun her programa ayrı ayrı kopyalanmasına gerek kalmaz.

Java'da ayrı bir bağlama adımı yoktur. Her sınıf kendi .class dosyasına derlenir. JVM'nin sınıf yükleyicisi (class loader), program çalışırken bir sınıfa ilk kez ihtiyaç duyulduğu anda o sınıfın dosyasını bulup yükler. Bir sınıf dosyası eksikse hata derleme ya da bağlama sırasında değil, çalışma sırasında ortaya çıkar.

4.2.8Derleme mi, yorumlama mı?

Derleme ile yorumlama arasındaki seçim bir değiş tokuştur. Bir yanda hız ve erken hata denetimi, öbür yanda hızlı deneme ve esneklik vardır. Tablo 4.5 üç yaklaşımı beş ölçüte göre karşılaştırır.

Bir oyun motoru ya da bir video kodlayıcı her milisaniyeyi önemser; derlenmiş C ya da C++ bu yüzden tercih edilir. Bir veri analisti bir veri kümesine farklı sorular sorarken her denemeden sonra derleme beklemek istemez; Python'un “kaydet ve çalıştır” döngüsü ona uygundur. Bir bankanın sunucu yazılımı yıllarca çalışır ve farklı donanımlara taşınır. Java'nın taşınabilir bytecode'u ve JIT ile kazandığı hız bu ihtiyaca uyar. Aynı dil için hem derleyici hem yorumlayıcı yazılabilmesi de bu değiş tokuşun sonucudur.

4.3Programlama dilleri

Bugün kullanılan programlama dillerinin sayısı yüzlerle ölçülür. Hepsini tek tek tanımak ne mümkündür ne de gereklidir. Dilleri birkaç ölçüte göre gruplamak, yeni bir dille karşılaşıldığında onu yerine oturtmayı kolaylaştırır. Donanıma yakınlık, ortaya çıkış dönemi, kullanım amacı, düşünme biçimi ve tip denetiminin zamanı bu ölçütlerin başlıcalarıdır.

4.3.1Dillerin seviyesi

Şekil 4.14 dilleri bir merdiven üzerinde dizer. En altta makine dili vardır: 10110000 01100001. Bu iki bayt, Intel uyumlu işlemcilerde “AL yazmacına 61h (onaltılı 61, onluk 97) değerini yükle” komutudur. Assembly aynı komutu MOV AL, 61h diye yazar. Bir basamak yukarıda C vardır: x = x + 1; satırı yazmaçlardan söz etmez, bir değişkenden söz eder. Java ve C# daha da yukarıdadır; bellek yönetimini programcıdan alır. Python en üsttedir: print(x) yazmak için bir sınıf ya da tip bildirimi gerekmez.

Merdivende yukarı çıkmak bir kazanç ve bir bedel getirir. Kazanç, aynı işi daha az ve daha anlaşılır satırla yazmaktır. Bir dizgiyi ekrana yazmak Python'da tek satırdır; assembly'de onlarca satır sürebilir. Bedel, donanım üzerindeki denetimin azalmasıdır. Bir sürücü yazılımı belirli bir bellek adresine belirli bir anda yazmak zorundaysa C ya da assembly gibi alt basamaklardaki diller gerekir. Bu yüzden seviye bir kalite ölçüsü değildir; bir dilin soyutlama düzeyini anlatır. Yüksek seviyeli bir dil düşük seviyeli bir dilden “daha iyi” değildir, başka işlere daha uygundur.

4.3.2Programlama dillerinin gelişimi

İlk bilgisayarlar doğrudan makine diliyle programlandı. Programcılar komutları ikili sayılar olarak yazıyor, bazen anahtarları elle tek tek çeviriyordu. 1940'ların sonunda assembly ortaya çıktı: komutlara akılda kalır adlar verildi ve bu adları ikiliye çeviren assembler programları yazıldı. Şekil 4.15 sonraki yetmiş yılı bir zaman çizelgesinde özetler.

Gelişim üç döneme ayrılabilir.

• 1940–1960. Makine dili ve assembly dönemi. 1957'de IBM'de John Backus'un ekibi FORTRAN'ı geliştirdi. FORTRAN, bilimsel formülleri neredeyse matematikteki gibi yazmayı sağlayan ilk yaygın yüksek seviyeli dildir. 1959'da iş ve muhasebe uygulamaları için COBOL tasarlandı. 1964'te Dartmouth Koleji'nde öğrencilerin programlama öğrenmesi için BASIC geliştirildi.
• 1970–1990. 1972'de Bell Laboratuvarları'nda Dennis Ritchie C dilini geliştirdi. UNIX işletim sistemi büyük ölçüde C ile yeniden yazıldı. C bir yandan donanıma yakın, öbür yandan farklı işlemcilere taşınabilir olduğu için sistem programlamanın temel dili oldu. 1983'te Bjarne Stroustrup, C'ye sınıf ve nesne kavramlarını ekleyen C++'ı duyurdu.
• 1990 sonrası. 1991'de Python, 1995'te Java ve JavaScript, 2000'de C# ortaya çıktı. Bu dillerin ortak noktası, bellek yönetimini programcıdan alan yönetilen ortamlar ve web'e uygunluktur. Zengin kütüphaneleri ve açık kaynak ekosistemleri de yaygınlaşmalarında etkili oldu. Daha yakın dönemde Go (2009) eşzamanlı sunucu programlarına, Rust (1.0 sürümü 2015) ise güvenli sistem programlamaya odaklandı.

Bu tarihte bir eğilim göze çarpar: her yeni kuşak, öncekinin programcıya bıraktığı bir işi üstlendi. Assembly ikili kodlamayı, FORTRAN yazmaç yönetimini, Java bellek yönetimini programcının elinden aldı. Programcıya kalan iş, problemin kendisine biraz daha yaklaştı.

4.3.3Kullanım alanları ve dil seçimi

Programlar çok farklı ortamlarda çalışır ve her ortamın ihtiyaçları başkadır. Başlıca kullanım alanları şunlardır:

• Web: tarayıcıda çalışan arayüzler (istemci), isteklere yanıt veren sunucu programları ve web servisleri.
• Mobil: telefon ve tablet uygulamaları.
• Veri ve yapay zekâ: veri analizi, istatistiksel modelleme, makine öğrenmesi ve otomasyon.
• Sistem: işletim sistemleri, aygıt sürücüleri ve bir ev aletinin içindeki gömülü yazılım.
• Bilimsel hesaplama: simülasyon ve mühendislik çözümleri; bir köprünün yük altındaki davranışı ya da bir devrenin frekans yanıtı.
• Oyun: oyun motorları, grafik ve kullanıcıyla etkileşim.

Her alanda bazı diller öne çıkar (Şekil 4.16). Tarayıcıda çalışan arayüzler için JavaScript (ve onun tipli bir uzantısı olan TypeScript) neredeyse tek seçenektir, çünkü tarayıcıların doğrudan çalıştırdığı dil budur. Android uygulamaları Kotlin ya da Java ile, iOS uygulamaları Swift ile yazılır; bu platformların resmî araçları bu dilleri destekler. Veri analizinde Python ve R, zengin kütüphaneleri sayesinde yaygındır. Gömülü sistemlerde bellek ve işlemci kısıtlı olduğundan C, C++ ve Rust tercih edilir. Kurumsal sunucularda Java, C# ve Go sık görülür.

Dil seçerken önce problem alanı ve programın çalışacağı platform değerlendirilir. Sonra şu sorular sorulur. Gereken işi yapan hazır kütüphaneler var mı? Dilin topluluğu soruların yanıtını bulmaya yetecek kadar büyük mü? Program yıllarca bakım görecekse o dili bilen geliştirici bulmak kolay mı? Hız ve bellek kullanımı ne kadar önemli? Güvenlik açısından dilin bir zayıflığı var mı? Ekip hangi dili zaten biliyor? Program nasıl dağıtılacak?

4.3.4Dil türleri

Diller kullanım amacına göre de gruplanır. Bir dil birden fazla gruba girebilir; Python hem genel amaçlı hem de bir betik dilidir.

Genel amaçlı diller (general-purpose languages) değişken, karar, döngü ve fonksiyon gibi yapıların tamamını sunar. Bu yapılarla, ilke olarak, bilgisayarın yapabileceği her hesap yazılabilir. Tablodaki for satırı Java'da üç tur dönen bir döngünün başıdır.

Alana özgü diller (domain-specific languages) tek bir işi çok iyi yapar. SQL veri tabanını sorgulamak için tasarlanmıştır. Tablodaki satır, öğrenci tablosundan ortalaması 60 ve üzeri olanların adlarını getirir. Satır, sonucun nasıl bulunacağını değil, ne istendiğini söyler; tabloyu nasıl tarayacağına veri tabanı yönetim sistemi karar verir. Excel'deki =ORTALAMA(B2:B30) gibi formüller de alana özgü bir dildir: hücrelerde hesap yapar.

Betik dilleri (scripting languages) tekrarlanan işleri otomatikleştirmek için kullanılır. Tablodaki PowerShell komutu, bulunduğu klasördeki bütün .txt dosyalarını yedek klasörüne kopyalar. Yüzlerce dosyayı elle kopyalamak yerine bu tek satır çalıştırılır. Betik dilleri genellikle yorumlanır; yazılan satır hemen denenebilir.

İşaretleme dilleri (markup languages) bir belgenin yapısını tanımlar. HTML'deki <h1>Başlık</h1> “bu metin birinci düzey başlıktır” der. İşaretleme dillerinde karar ve döngü yoktur; bir koşula göre farklı iş yapamaz ve bir işi tekrarlayamaz. Bu yüzden programlama dili sayılmazlar. Bir web sayfasında HTML yapıyı, CSS görünümü, JavaScript ise davranışı tanımlar; bu üçlüden yalnızca JavaScript bir programlama dilidir.

Bu gruplara blok tabanlı görsel diller de eklenebilir. Scratch gibi dillerde komutlar yazılmaz; renkli bloklar sürüklenip birbirine takılır. Bloklar yalnızca kurala uygun biçimde birleşebildiği için söz dizimi hatası yapılamaz. Bu özellik, programlamayı öğretmeye yeni başlanırken dikkati söz diziminden algoritmaya çevirir.

4.3.5Programlama paradigmaları

Aynı problemi çözmenin birden çok düşünme biçimi vardır. Biri adımları sırayla sayar, biri problemi birbiriyle konuşan nesneler olarak görür, biri de veriyi dönüştüren fonksiyonlar zinciri kurar. Bu düşünme biçimlerine programlama paradigması denir.

Şekil 4.17 üç yaklaşımı aynı görev üzerinde karşılaştırır: notlar = {70, 90, 80} dizisinin toplamını bulmak. Aşağıdaki Java programı üç yaklaşımı da içerir.

import java.util.Arrays;

public class Paradigmalar {
    static class Ogrenci {
        private final int[] notlar;
        Ogrenci(int[] notlar) { this.notlar = notlar; }
        int toplam() {
            int t = 0;
            for (int n : notlar) t += n;
            return t;
        }
    }

    public static void main(String[] args) {
        int[] notlar = {70, 90, 80};
        // buyurgan
        int toplam = 0;
        for (int n : notlar)
            toplam += n;
        System.out.println(toplam);
        // nesne yönelimli
        Ogrenci ogrenci = new Ogrenci(notlar);
        System.out.println(ogrenci.toplam());
        // fonksiyonel
        System.out.println(Arrays.stream(notlar).sum());
        System.out.println(Arrays.toString(notlar));
    }
}

240
240
240
[70, 90, 80]

Buyurgan çözüm, toplam adlı bir değişkeni 0 ile başlatır ve döngünün her turunda bu değişkeni değiştirir. Toplamın değerleri sırasıyla 0, 70, 160 ve 240'tır. Program bir tarif gibi okunur: “önce şunu yap, sonra bunu yap.” C ve assembly temelde buyurgan dillerdir.

Nesne yönelimli çözümde notlar bir Ogrenci nesnesinin içindedir. Toplamı hesaplama işi de aynı nesneye aittir: ogrenci.toplam(). Nesneyi kullanan kod, toplamın nasıl hesaplandığını bilmek zorunda değildir; yalnızca nesneye sorar. Program büyüdükçe bu düzen işe yarar. Öğrenciyle ilgili her şey tek bir yerde durur, değişiklik gerektiğinde nereye bakılacağı bellidir. Java, C++ ve C# nesne yönelimli dillerdir.

Fonksiyonel çözümde Arrays.stream(notlar).sum() ifadesi diziyi bir değer akışına çevirir ve akışı toplar. Ara durum tutan bir değişken yoktur ve dizinin kendisi değişmez. Programın son satırı bunu doğrular: dizi hâlâ [70, 90, 80]'dir. Fonksiyonel yaklaşım, aynı girdiye her zaman aynı çıktıyı veren ve dışarıdaki hiçbir şeyi değiştirmeyen fonksiyonları öne çıkarır. Böyle fonksiyonları sınamak ve birleştirmek kolaydır. Haskell tamamen fonksiyonel bir dildir; Python, JavaScript ve Java ise fonksiyonel öğeler de sunar.

Pek çok bugünkü dil birden fazla paradigmayı destekler. Java'da üç çözüm de yazılabilir; Python'da da öyle:

notlar = [70, 90, 80]
toplam = 0
for n in notlar:
    toplam += n
print(toplam)
print(sum(notlar))
from functools import reduce
print(reduce(lambda a, b: a + b, notlar, 0))

240
240
240

Python'daki reduce fonksiyonu, iki sayıyı toplayan küçük bir fonksiyonu dizinin öğelerine 0'dan başlayarak sırayla uygular: ((0 + 70) + 90) + 80 = 240. Hangi yaklaşımın seçileceği problemin yapısına ve ekibin alışkanlığına bağlıdır. Büyük programlar çoğu zaman üç yaklaşımı birlikte kullanır.

4.3.6Statik ve dinamik tipleme

Her değerin bir tipi vardır: 5 bir tam sayı, "beş" bir dizgi, true bir mantıksal değerdir. Diller, tiplerin ne zaman denetlendiğine göre ikiye ayrılır.

Java'da bir değişken bildirilirken tipi de yazılır: int x = 5;. Bu andan sonra x yalnızca tam sayı tutabilir. x = "beş"; satırı derleyicinin anlam çözümleme aşamasında yakalanır: “incompatible types: String cannot be converted to int”. Program hiç çalışmadan hata bulunur.

Python'da değişkenin tipi bildirilmez. Aynı ad önce bir sayıyı, sonra bir metni gösterebilir. Tip, değerin kendisinde taşınır:

x = 5
print(type(x).__name__)
x = "beş"
print(type(x).__name__)
print("a" + 1)

int
str
Traceback (most recent call last):
  File "dinamik.py", line 5, in <module>
    print("a" + 1)
          ~~~~^~~
TypeError: can only concatenate str (not "int") to str

İlk iki satırın çıktısı x'in önce int, sonra str (dizgi) tipinde bir değeri gösterdiğini söyler. İkisi de geçerlidir. Beşinci satırdaki "a" + 1 ise bir dizgiye sayı eklemeye çalışır ve TypeError verir. Önemli nokta hatanın ne zaman çıktığıdır. Python dosyayı ayrıştırırken bu satırda bir sorun görmez, çünkü satırın söz dizimi doğrudur. Hata ancak satır çalıştığında, önceki iki print satırının çıktısı ekrana yazıldıktan sonra ortaya çıkar. Bu satır programın nadiren çalışan bir dalında olsaydı, hata aylarca fark edilmeyebilirdi.

Bazı diller tip uyuşmazlığında hata vermek yerine tipleri sessizce dönüştürür. JavaScript bunun bilinen örneğidir. Aşağıdaki satırlar Node.js ile çalıştırılmıştır:

console.log("5" * 2);
console.log("5" + 2);
console.log(typeof ("5" * 2), typeof ("5" + 2));
console.log("5" - 2);

10
52
number string
3

"5" * 2 ifadesinde çarpma yalnızca sayılarla yapılabildiği için JavaScript "5" dizgisini 5 sayısına çevirir ve 10 bulur. "5" + 2 ifadesinde ise + dizgi birleştirme anlamına da geldiği için 2 dizgiye çevrilir ve "52" elde edilir. Üçüncü satır iki sonucun tiplerini gösterir: biri sayı, öbürü dizgidir. Aynı iki değer, işleme göre farklı tiplere dönüşmüştür. Bu tür sessiz dönüşümler kısa betiklerde kolaylık sağlar, büyük programlarda ise bulunması zor mantık hatalarına yol açar.

4.3.7Sözde koddan dillere

Bir algoritma önce sözde kodla yazılıp sonra bir dile çevrildiğinde, sözde koddaki her yapının dilde bir karşılığı bulunur. Tablo 4.8 en sık kullanılan yapıların Java ve Python karşılıklarını verir.

Sözde kodda atama için ← kullanılır, çünkü = işareti matematikte eşitlik anlamına gelir. Java ve Python atamayı = ile, eşitlik karşılaştırmasını == ile yazar. Java'daki giris, klavyeden okuyan bir Scanner nesnesidir. Python'da input() her zaman dizgi döndürür; sayı isteniyorsa int(...) ile çevrilmesi gerekir.

İki dil arasındaki en görünür fark blokların sınırlarıdır. Java bir bloğu süslü parantezlerle ({ }) belirler, her deyimi de ; ile bitirir. Python bunların ikisini de istemez; bloğu girinti belirler. Bu yüzden Python'da girinti yalnızca görünüş değildir, programın anlamının parçasıdır:

x = -3
if x > 0:
    print("pozitif")
print("bitti")
if x > 0:
    print("pozitif")
    print("bitti")

bitti

x = −3 olduğu için iki koşul da yanlıştır. İlk if bloğunda print("bitti") girintisizdir, yani bloğun dışındadır ve koşuldan bağımsız çalışır. İkinci blokta aynı satır girintilidir, bloğun içindedir ve koşul yanlış olduğu için çalışmaz. İki parça arasındaki tek fark dört boşluktur; çıktıda yalnızca bir “bitti” görünür.

toplam ← 0
her i ← 1 … n için
    toplam ← toplam + i
yaz "Toplam: ", toplam

public class Bilesik {
    public static void main(String[] args) {
        int toplam = 0;
        for (int i = 1; i <= 5; i++) {
            toplam = toplam + i;
        }
        System.out.println("Toplam: " + toplam);
    }
}

n = 5
toplam = 0
for i in range(1, n + 1):
    toplam = toplam + i
print("Toplam:", toplam)
i = 1
while i <= 3:
    print(i)
    i = i + 1
print("bitti")

Toplam: 15

Toplam: 15
1
2
3
bitti

4.4Problem çözme

Program yazmak klavyenin başında başlamaz. Önce problemin ne olduğu anlaşılır, sonra elle birkaç örnek çözülür, en son kod yazılır. Bu sıra atlandığında ortaya çoğu zaman “çalışan ama yanlış işi yapan” programlar çıkar.

4.4.1Problemden programa

Örnek problem basittir: bir dikdörtgenin alanını hesaplayan bir program. Şekil 4.18 bu problemin programa dönüşmesini beş aşamada gösterir. Aşamaların her birinin çıktısı bir sonrakinin girdisidir.

1. Problemi tanımla. Ne istendiği netleşir: dikdörtgenin alanı. Programın girdisi en ve boy, çıktısı alandır. Bir de kısıt vardır: bir uzunluk sıfır ya da negatif olamaz, yani en ve boy 0'dan büyük olmalıdır. Kısıtlar çoğu zaman problemde açıkça yazmaz; problemi tanımlayan kişinin onları bulması gerekir.
2. Örnekleri dene. Elle birkaç örnek çözülür: 3 × 4 = 12, 5 × 5 = 25. Bir de sınır durumu düşünülür: en 0 olursa ne olmalı? Kısıta göre bu girdi geçersizdir. Elle çözülen örnekler, sonradan programın doğru çalışıp çalışmadığını sınamak için beklenen sonuçları da verir.
3. Algoritmayı kur. Dilden bağımsız adımlar sözde kodla yazılır: en'i oku, boy'u oku, alanı hesapla, alanı yaz.
4. Koda dönüştür. Algoritma seçilen dile çevrilir. Java'da hesap satırı alan = en * boy;, yazdırma satırı System.out.println(alan); olur.
5. Test et. Program elle çözülen örneklerle çalıştırılır. 3 ve 4 için 12 çıkar: doğru. −2 ve 4 için −8 çıkar: bir alan negatif olamayacağına göre bu yanlıştır. Hata kodda değil, algoritmadadır; algoritma kısıtı hiç denetlemiyordur. Algoritmaya dönülür ve “en ve boy 0'dan büyük değilse hata ver” adımı eklenir.

Son aşamadaki geri dönüş sürecin doğal bir parçasıdır. Aşamalar düz bir çizgi değil, bir döngü oluşturur: test, kodlamada ya da algoritmada bir eksik bulursa ilgili aşamaya dönülür. Düzeltilmiş algoritma şudur:

oku en
oku boy
eğer en > 0 ve boy > 0 ise
    alan ← en × boy
    yaz "Alan: ", alan
değilse
    yaz "Geçersiz ölçü"

Bu algoritmanın Java karşılığı aşağıdadır. && işareti Java'da “ve” bağlacıdır: iki koşul da doğruysa sonuç doğrudur.

import java.util.Scanner;

public class Alan {
    public static void main(String[] args) {
        Scanner giris = new Scanner(System.in);
        int en = giris.nextInt();
        int boy = giris.nextInt();
        if (en > 0 && boy > 0) {
            int alan = en * boy;
            System.out.println("Alan: " + alan);
        } else {
            System.out.println("Geçersiz ölçü");
        }
    }
}

Program dört girdiyle çalıştırılmıştır: (3, 4), (−2, 4), (0, 5) ve (5, 2). Çıktılar sırasıyla şunlardır:

Alan: 12

Geçersiz ölçü

Geçersiz ölçü

Alan: 10

4.4.2Alan algoritmasını izleme

Bir algoritmanın doğru çalıştığından emin olmanın en güvenilir yolu, onu kâğıt üzerinde satır satır izlemektir. Her adımda değişkenlerin değeri bir tabloya yazılır. Bu tabloya izleme tablosu (trace table) denir. Değişkenler bellekte birer kutu gibi düşünülebilir: oku en satırı klavyeden gelen sayıyı “en” adlı kutuya yazar. Henüz değer verilmemiş kutular tabloda “—” ile gösterilir.

Tablo 4.9 algoritmanın en = 3, boy = 4 girdisiyle çalışmasını izler.

Tablo 4.10 aynı algoritmayı en = −2, boy = 4 girdisiyle izler. Bu, test aşamasında yanlış sonuç veren girdidir.

İkinci izlemede alan kutusu baştan sona boş kalır. Program “ise” dalına hiç girmemiştir. Testte bulunan hata böylece düzeltilmiştir: −2 için artık −8 değil, bir uyarı yazılır.

4.5Yazılım geliştirme

Dikdörtgen alanı gibi küçük bir program tek kişinin bir saatlik işidir. Bir bankanın mobil uygulaması ya da bir hastanenin randevu sistemi ise onlarca kişinin aylarca, hatta yıllarca süren işidir. Bu ölçekte işin düzenlenmesi en az kodun kendisi kadar önemlidir.

4.5.1Yazılım geliştirme süreci

Problemden programa giden yol büyük ölçekte altı aşamaya ayrılır (Şekil 4.19). Aşamalar bir “öğrenci not ortalamasını hesaplayan uygulama” üzerinden şöyle açıklanabilir.

1. Gereksinim. Kullanıcı ne istiyor? Öğrenci her dersin notunu ve kredisini girecek, uygulama ağırlıklı ortalamayı gösterecek. Not 0–100 arasında olmalı. Uygulama telefonda çalışacak. Gereksinimler kullanıcıyla konuşularak yazılır ve sonraki aşamaların hepsi bu yazıya dayanır.
2. Tasarım. Ekranlar, veri ve algoritmalar planlanır. Hangi ekranda ne girilecek? Notlar nerede saklanacak? Ortalama hangi formülle hesaplanacak? Akış diyagramı ve sözde kod bu aşamanın araçlarıdır.
3. Kodlama. Tasarım bir programlama diliyle yazılır.
4. Test. Beklenen sonuçlar gerçek sonuçlarla karşılaştırılır. 60 puanlı 3 kredilik ve 90 puanlı 2 kredilik iki ders için beklenen ortalama (60 · 3 + 90 · 2) / 5 = 360 / 5 = 72'dir. Uygulama 75 gösteriyorsa (iki notun ağırlıksız ortalaması) bir hata vardır ve kodlamaya geri dönülür.
5. Dağıtım. Program kullanıcıya ulaştırılır: uygulama mağazasında yayımlanır ya da kurulum dosyası paylaşılır.
6. Bakım. Kullanım başladıktan sonra yeni hatalar bulunur, yeni istekler gelir: “harf notunu da göstersin”. Bu istekler yeni gereksinimlerdir ve döngü yeniden başlar.

Aşamalar projeye göre ardışık ya da yinelemeli yürütülür. Kullanıcıdan gelen geri bildirim gereksinimi ve tasarımı değiştirebilir. Bir yazılımın ömrü boyunca harcanan emeğin büyük kısmı ilk sürüme değil, bakıma gider. Bu yüzden kodun ilk günden okunabilir ve değiştirilebilir yazılması önemlidir.

4.5.2Geliştirme yaklaşımları

Altı aşamanın nasıl düzenleneceğine dair farklı yaklaşımlar vardır (Şekil 4.20).

Şelale modelinde (waterfall model) aşamalar sırayla ve birer kez yapılır. Gereksinimler tamamen yazılmadan tasarıma, tasarım bitmeden kodlamaya geçilmez. Her aşamanın sonunda bir belge üretilir. Bu düzenin güçlü yanı açıklığıdır: kimin ne zaman ne yapacağı bellidir. Zayıf yanı değişikliğe kapalı olmasıdır. Kodlama sırasında gereksinimde bir eksik fark edilirse geri dönmenin maliyeti yüksektir.

Çevik yaklaşımda (agile) iş kısa döngülere bölünür; her döngü birkaç haftalıktır. Her döngüde biraz planlama, biraz kodlama ve test yapılır. Döngü sonunda kullanıcıya çalışan bir sürüm gösterilir ve geri bildirim alınır. Böylece yanlış anlaşılan bir gereksinim aylar sonra değil, birkaç hafta içinde ortaya çıkar. Bu yaklaşımın bedeli, kullanıcıyla sürekli iletişim kurma gereğidir.

Prototiplemede (prototyping) gerçek ürüne başlamadan önce hızlıca bir taslak hazırlanır. Taslakta ekranlar vardır ama arkalarında gerçek hesap ya da veri tabanı bulunmayabilir. Kullanıcı ne istediğini tam anlatamıyorsa, taslağı gördüğünde fikri netleşir. Taslağın amacı gereksinimi görünür kılmaktır. Ürünün kendisi sanılıp doğrudan kullanıma sunulmamalıdır.

4.5.3Geliştirme araçları

Bir geliştiricinin günlük işi bir döngüdür: kodu yaz, çevir ve çalıştır, sonucu sına, hata varsa bul, düzelt ve yeniden dene. Bu döngünün her adımında farklı bir araç devreye girer (Şekil 4.21).

• Kod düzenleyici ve IDE. Kod bir metin düzenleyicide yazılabilir, ama programcılar çoğunlukla bir tümleşik geliştirme ortamı (IDE, integrated development environment) kullanır. IDE yazılan kodu renklendirir, adları tamamlar, söz dizimi hatalarını yazarken altını çizerek gösterir ve projenin dosyalarını düzenler. IntelliJ IDEA, Eclipse ve Visual Studio Code yaygın örneklerdir.
• Derleyici ve çalışma ortamı. Programı çevirir ve çalıştırır: javac ve JVM, Python yorumlayıcısı, C derleyicisi.
• Hata ayıklayıcı (debugger). Programı istenen satırda durdurur, değişkenlerin o anki değerlerini gösterir ve satır satır ilerletir.
• Sürüm kontrolü. Dosyalardaki her değişikliği kaydeder; ekip çalışmasını mümkün kılar.
• Test araçları. Beklenen davranışı otomatik olarak doğrular. Programcı bir kez “bu girdiye bu çıktı beklenir” diye yazar, araç her değişiklikten sonra bütün testleri saniyeler içinde yeniden çalıştırır. Java'da JUnit bu işin bilinen aracıdır.
• Paket yöneticisi (package manager). Programın kullandığı hazır kütüphaneleri (bağımlılıkları) indirir, sürümlerini izler ve günceller: Python'da pip, JavaScript'te npm, Java'da Maven ve Gradle.

4.5.4Sürüm kontrolü

Bir öğrenci ödevini yazarken dosyanın kopyalarını odev_son.java, odev_son2.java, odev_GERCEKSON.java diye saklıyorsa, sürüm kontrolünü elle yapmaya çalışıyordur. Bu yöntem birkaç gün içinde karışır. Hangi kopyada hangi değişikliğin yapıldığı unutulur; iki kişi aynı dosyada çalışıyorsa iş içinden çıkılmaz hâle gelir.

Şekil 4.22 dikdörtgen programının geçmişini gösterir. K1 ilk sürümdür. K2'de alan hesabı, K3'te çevre hesabı eklenmiştir. K2'den sonra bir geliştirici yeni bir hesap denemek için bir dal açmış (D1) ve ana kodu bozmadan orada çalışmıştır. Deneme başarılı olunca dal ana dala birleştirilmiştir (K4). Deneme başarısız olsaydı dal silinir, ana dal hiç etkilenmezdi. K3'teki bir değişiklik hata getirdiyse proje tek komutla K2'deki hâline döndürülebilir.

En yaygın sürüm kontrol aracı Git'tir. Git'te yukarıdaki geçmiş birkaç komutla oluşur. git init bir klasörü depo hâline getirir. git add değişen dosyaları bir sonraki kayda hazırlar. git commit -m "alan eklendi" kaydı açıklamasıyla oluşturur. git branch deneme yeni bir dal açar; git merge deneme o dalı bulunulan dala birleştirir. git log ise bütün kayıtları kim, ne zaman ve hangi açıklamayla bilgileriyle listeler.

Ekip çalışmasında her geliştiricinin bilgisayarında deponun bir kopyası bulunur. GitHub ve GitLab gibi hizmetler depoyu ağ üzerinde saklar ve kopyalar arasında ortak bir buluşma noktası olur. İki kişi aynı dosyanın farklı satırlarını değiştirdiyse Git değişiklikleri kendiliğinden birleştirir. Aynı satırı değiştirdilerse bir çakışma (merge conflict) oluşur. Git iki sürümü yan yana gösterir ve hangisinin kalacağını bir kişinin seçmesini ister.

4.6Temel programlama yapıları

Diller birbirinden ne kadar farklı görünürse görünsün, hepsi aynı birkaç yapı taşı üzerine kurulur. Değerler adlandırılmış yerlerde saklanır ve ifadelerle hesaplanır. Koşullara göre farklı yollar seçilir, işler tekrarlanır. Sık yapılan işlere ad verilir, çok sayıda değer tek bir ad altında toplanır. Yapılar önce sözde kodla, sonra Java ve Python karşılıklarıyla verilir.

4.6.1Değişkenler ve veri tipleri

Değişken, üzerinde adı yazılı bir kutu gibi düşünülebilir (Şekil 4.23). yas kutusunda 19, boy kutusunda 1.75, ad kutusunda “Ali”, gecti kutusunda doğru değeri vardır. Kutuya yeni bir değer yazıldığında eskisi silinir. Kutunun tipi, içine ne konabileceğini sınırlar: tam sayı kutusuna metin konamaz.

Kodda ondalık ayırıcı noktadır: Java ve Python 1,75 yazımını sayı olarak kabul etmez. Bu notta düz metinde Türkçe yazım kuralına uyularak virgül (1,75), kod ve program çıktılarında nokta (1.75) kullanılır.

Veri tipi seçimi değerin anlamından çıkar. Bir öğrencinin adı harflerden oluştuğu için dizgidir. Not ortalaması 81,67 gibi kesirli olabileceği için kayan noktalı sayıdır. “Dersi geçti mi?” sorusunun yanıtı yalnızca evet ya da hayır olabileceği için mantıksaldır. Öğrenci sayısı kesirli olamayacağı için tam sayıdır.

Değişkenlere anlamlı adlar vermek programın amacını görünür kılar. a = b * c satırı hiçbir şey anlatmaz; alan = en * boy satırı kendini açıklar. Adlar programın okunabilirliğinin en ucuz ve en etkili aracıdır.

4.6.2İşlem önceliği

Bir ifadede birden çok işlem varsa hangisinin önce yapılacağını işlem önceliği (operator precedence) belirler. Programlama dillerindeki kurallar okulda öğrenilen matematik kurallarıyla aynıdır:

1. Parantez içi önce hesaplanır.
2. Çarpma, bölme ve mod (kalan) toplamadan ve çıkarmadan önce yapılır.
3. Toplama ve çıkarma en son yapılır.
4. Aynı düzeydeki işlemler soldan sağa yapılır.

Mod işlemi (Java ve Python'da %) bölmeden kalanı verir: 7 mod 3, 7'nin 3'e bölümünden kalan olan 1'dir. Tablo 4.13 bu kuralların beş ifadeye uygulanmasını gösterir.

Derleyici işlem önceliğini ifadenin ağacına yerleştirir. Şekil 4.24 2 + 3 × 4 ifadesinin ağacını gösterir: çarpma daha derinde olduğu için önce yapılır, toplama kökte olduğu için en son yapılır.

Tablodaki ifadeler Java'da da aynı sonuçları verir. Aşağıdaki program tablonun beş ifadesini ve soldan sağa kuralını sınayan iki ek ifadeyi yazdırır:

public class Oncelik {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);
        System.out.println((2 + 3) * 4);
        System.out.println(20 / 4 * 2);
        System.out.println(10 - 4 - 3);
        System.out.println(7 % 3 + 1);
        System.out.println(20 / (4 * 2));
        System.out.println(10 - (4 - 3));
    }
}

14
20
10
3
2
2
9

Son iki satır soldan sağa kuralının neden önemli olduğunu gösterir. 20 / 4 × 2 ifadesi 10 verir; parantezle 20 / (4 × 2) yazılınca sonuç 2'dir. Java'da bu ikinci sonuç aslında 2,5 olmalıydı: iki tam sayının bölümü tam sayı olduğu için 20 / 8 işleminin kesirli kısmı atılır. Benzer biçimde 10 − 4 − 3 = 3 iken 10 − (4 − 3) = 9'dur.

Python'da aynı ifadeler bir fark dışında aynı sonuçları verir:

185.0
81.67
52.33
14 20 10.0 3 2
10

Çıktının dördüncü satırında 20 / 4 * 2 ifadesi 10.0 verir, çünkü Python'da / işleci her zaman kayan noktalı sonuç üretir. Tam sayı bölmesi için // işleci vardır ve son satırdaki gibi 10 verir. İlk satırdaki 185.0 ise eksik parantezin sonucudur. Bu hata Python'da da aynen ortaya çıkar.

4.6.3Karar ve döngü

Bir program yalnızca yukarıdan aşağı sırayla çalışsaydı, her girdi için aynı adımları yapardı. Gerçek problemler ise koşullara göre farklı davranmayı ve aynı işi tekrar tekrar yapmayı gerektirir. Bunu sağlayan iki yapı karar ve döngüdür (Şekil 4.25).

Karar yapısında her çalıştırmada iki yoldan yalnızca biri izlenir. Alan algoritmasında koşul doğruysa alan hesaplanır, yanlışsa uyarı yazılır; ikisi aynı çalıştırmada birlikte olmaz. Döngüde ise akış, gövdenin sonunda koşula geri döner. Koşul her turun başında yeniden denetlenir. Koşul yanlış olunca döngüden çıkılır ve döngüden sonraki satıra geçilir.

Bir döngünün bitebilmesi için gövdenin içinde koşulu etkileyen bir değişiklik olmalıdır. Koşul i ≤ 3 ise gövde i'yi bir gün 3'ün üstüne çıkarmalıdır. Böyle bir değişiklik yoksa koşul hep doğru kalır ve döngü hiç bitmez.

4.6.4Döngü izleme: sonsuz döngü

Aşağıdaki sözde kod 1'den 3'e kadar sayıları yazmak için yazılmıştır. Programcı ilk sürümde 4. satırı unutmuştur:

i ← 1
i ≤ 3 iken tekrarla
    yaz i
    i ← i + 1      // ilk sürümde yoktu
yaz "bitti"

Tablo 4.14 ilk sürümün ilk birkaç adımını izler. i ← 1 ile döngü değişkeni hazırlanır. Koşul 1 ≤ 3 doğrudur, gövdeye girilir ve 1 yazılır. Gövdede başka satır olmadığı için koşula dönülür. i hâlâ 1'dir, koşul yine doğrudur. Durum bir önceki turla birebir aynıdır.

Koşulu yanlış yapacak bir değişiklik olmadığı için döngü hiç bitmez (Şekil 4.26). Ekran 1'lerle dolar. Konsolda çalışan bir program ancak Ctrl+C tuşlarıyla durdurulabilir.

Düzeltilmiş sürümde gövdeye i ← i + 1 satırı eklenir. Tablo 4.15 bu sürümü baştan sona izler.

Döngü değişkeni artık her turda ilerler. Üçüncü turda koşul 3 ≤ 3 yine doğrudur, çünkü ≤ eşitliği de kapsar. Bu ayrıntı atlanırsa sayıların yalnızca 1 ve 2'ye kadar yazılacağı sanılabilir. Döngü bittiğinde gövde 3 kez çalışmış, koşul ise 4 kez denetlenmiştir: üç doğru ve bir yanlış. Bir döngüde koşul her zaman gövdeden bir fazla denetlenir. Son denetim döngüyü bitiren denetimdir. Java karşılığı ve çıktısı:

public class Dongu {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 3) {
            System.out.println(i);
            i = i + 1;
        }
        System.out.println("bitti");
    }
}

1
2
3
bitti

4.6.5Fonksiyonlar ve diziler

Programlar büyüdükçe iki ihtiyaç ortaya çıkar. Birincisi, aynı işin programın birçok yerinde yapılmasıdır; dikdörtgen alanı belki on yerde hesaplanır. İkincisi, çok sayıda benzer değerin saklanmasıdır; bir sınıfın 40 öğrencisinin notları için 40 ayrı değişken tanımlamak anlamsızdır. Fonksiyon birinci ihtiyacı, dizi ikincisini karşılar (Şekil 4.27).

Fonksiyon bir görevi adlandırır. kare(x) fonksiyonu “bir sayının karesini al” görevinin adıdır. Fonksiyonu kullanan kod, karenin nasıl hesaplandığıyla ilgilenmez; yalnızca kare(4) yazar ve 16 alır. Formül tek bir yerde durur. Formülde bir hata varsa bir kez düzeltilir ve düzeltme fonksiyonun çağrıldığı her yere yansır.

Dizide değerler sıra numaralarıyla seçilir. Java, C ve Python'da sıra numarası 0'dan başlar. Dört öğeli notlar dizisinde ilk öğe notlar[0] = 85, son öğe notlar[3] = 64'tür. Son indis her zaman uzunluk − 1'dir. Bu kural ilk bakışta tuhaf gelse de bir mantığı vardır: indis, öğenin dizinin başından kaç adım uzakta olduğunu söyler; ilk öğe başlangıçtan sıfır adım uzaktadır.

Bu iki yapı programı küçük, ayrı ayrı sınanabilir parçalara böler. Not ortalaması hesaplayan bir program, notları okuyan, ortalamayı hesaplayan ve harf notunu bulan üç fonksiyona ayrılabilir; notlar da tek bir dizide tutulur.

4.6.6Fonksiyon çağrısını izleme

Aşağıdaki sözde kod, alan fonksiyonunu tanımlar ve iki kez çağırır:

fonksiyon alan(en, boy)
    sonuc ← en × boy
    döndür sonuc
son
a ← alan(3, 4)
b ← alan(2, 5)
yaz a + b

Fonksiyon çağrıları bellekte çağrı yığını (call stack) adı verilen bir yapıyla izlenir. Her çağrı için yığının üstüne yeni bir çerçeve (stack frame) eklenir. Çerçevede fonksiyonun parametreleri ve kendi değişkenleri durur. Fonksiyon bitince çerçevesi yığından kaldırılır. Yığının en üstündeki çerçeve, o anda çalışan fonksiyonundur. Tablo 4.16 programı adım adım izler.

İzlemeden üç sonuç çıkar. Birincisi, fonksiyon tanımı tek başına hiçbir şey yapmaz; ancak çağrıldığında çalışır. İkincisi, her çağrı kendi çerçevesini açar. Birinci çağrının sonuc = 12 değeri ikinci çağrının çerçevesinde görünmez, çünkü birinci çerçeve çoktan kaldırılmıştır. Fonksiyonun içindeki değişkenler yalnızca o çağrı sürdükçe yaşar. Üçüncüsü, ana program fonksiyonun içini görmez; yalnızca döndürülen değeri alır. Bir kez yazılan fonksiyon iki kez kullanılmış, alan formülü tek bir yerde kalmıştır (Şekil 4.28).

Java karşılığında fonksiyonlara metot denir. static int alan(int en, int boy) başlığı, metodun iki tam sayı aldığını ve bir tam sayı döndürdüğünü söyler:

public class AlanFonksiyon {
    static int alan(int en, int boy) {
        int sonuc = en * boy;
        return sonuc;
    }

    public static void main(String[] args) {
        int a = alan(3, 4);
        int b = alan(2, 5);
        System.out.println(a + b);
    }
}

22

4.6.7Dizi ile ortalama

Aşağıdaki sözde kod dört notun ortalamasını bir dizi ve bir döngüyle hesaplar:

notlar ← [85, 72, 90, 64]
toplam ← 0
her i ← 0, 1, 2, 3 için
    toplam ← toplam + notlar[i]
ort ← toplam / 4
yaz "Ortalama: ", ort

Toplamı tutan değişkene biriktirici denir. Biriktirici döngüden önce 0 ile başlatılır, her turda bir değer daha eklenir. Başlangıç değeri verilmeseydi toplamın ilk değeri belirsiz olurdu. Tablo 4.17 döngünün her turunu izler.

Döngü dört tur sonra biter. Son indis 3'tür, yani uzunluk − 1. Sonuç “Ortalama: 77.75” olarak yazılır (Şekil 4.29). Java programında döngü sınırı sabit 4 yerine dizinin uzunluğu olan notlar.length ile yazılmıştır. Böylece diziye not eklenince döngü kendiliğinden uyum sağlar. Bölme de 4.0 ile yapılır ki sonuç tam sayıya yuvarlanmasın:

public class Ortalama {
    public static void main(String[] args) {
        int[] notlar = {85, 72, 90, 64};
        int toplam = 0;
        for (int i = 0; i < notlar.length; i++) {
            toplam = toplam + notlar[i];
        }
        double ort = toplam / 4.0;
        System.out.println("Ortalama: " + ort);
    }
}

Ortalama: 77.75

Python'da aynı hesap daha kısadır. sum ve len hazır fonksiyonları döngüyü programcıdan gizler:

notlar = [85, 72, 90, 64]
toplam = 0
for i in range(4):
    toplam = toplam + notlar[i]
ort = toplam / 4
print("Ortalama:", ort)
print(sum(notlar) / len(notlar))

Ortalama: 77.75
77.75

Döngü bir tur fazla dönseydi ne olurdu? Dört öğeli dizide 4 numaralı hücre yoktur. Java bu durumu bir çalışma zamanı hatasıyla bildirir:

public class DiziDisi {
    public static void main(String[] args) {
        int[] notlar = {85, 72, 90, 64};
        System.out.println(notlar[3]);
        System.out.println(notlar[4]);
    }
}

64
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at DiziDisi.main(DiziDisi.java:5)

notlar[3] sorunsuz okunur ve 64 yazılır. notlar[4] istendiğinde JVM programı durdurur. İletideki “Index 4 out of bounds for length 4” ifadesi “uzunluğu 4 olan dizide 4 numaralı indis sınırların dışında” demektir. Döngü sınırının i <= notlar.length diye yazılması bu hatanın en sık nedenidir; doğrusu i < notlar.length'tir.

4.6.8Kütüphaneler ve API

Karekök almak, bir listeyi sıralamak ya da bir dosyayı okumak her programcının sık ihtiyaç duyduğu işlerdir. Her programcının bunları sıfırdan yazması hem zaman kaybı hem de hata kaynağı olurdu. Bu yüzden diller hazır, test edilmiş fonksiyonlarla birlikte gelir.

API bir sözleşme gibidir (Şekil 4.30). Karekök fonksiyonunun API'si üç şey söyler: fonksiyonun adı, bir sayı aldığı ve o sayının karekökünü döndürdüğü. Fonksiyonun içinde hangi yöntemin kullanıldığı, kayan nokta ayrıntılarının nasıl ele alındığı kullanıcıyı ilgilendirmez. Kütüphaneyi yazanlar içini daha hızlı bir yöntemle değiştirse bile, API aynı kaldıkça onu kullanan programlar değişmeden çalışmaya devam eder.

Tablodaki sonuçlar gerçek çalıştırmalardan alınmıştır. Java'da Math.sqrt sonucu her zaman double döndürür; bu yüzden 4 değil, 4.0 yazılır. Java'da bir dizginin uzunluğu bir fonksiyonla değil, dizginin kendi metoduyla bulunur: "Giresun".length().

public class Kutuphane {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(16));
        System.out.println(Math.max(3, 8));
        System.out.println("Giresun".length());
    }
}

4.0
8
7

import math
print(math.sqrt(16))
print(max(3, 8))
print(len("Giresun"))

4.0
8
7

API kavramı kütüphanelerle sınırlı değildir. Bir hava durumu uygulaması, bir meteoroloji hizmetinin ağ üzerinden sunduğu API'yi çağırır: şehir adını gönderir, sıcaklığı alır. Uygulamayı yazanlar o hizmetin sunucularında ne olduğunu bilmez, yalnızca API'nin belgesini okur.

4.7Hata ayıklama

Her programcı hata yapar; deneyimli programcıyı ayıran, hatayı bulmanın düzenli bir yolunu bilmesidir. Bir programdaki hatayı bulup giderme işine hata ayıklama (debugging) denir.

4.7.1Hata ayıklama teknikleri

Hata ayıklama bir tahmin oyunu değil, adım adım yürüyen bir araştırmadır. Aşağıdaki teknikler bu araştırmanın araçlarıdır.

1. Hatayı yeniden üret. Aynı girdiyle hata her seferinde çıkıyor mu? Hatayı her istendiğinde ortaya çıkaran girdi bulunmadan aramaya başlamak boşa çabadır. Bu girdi, düzeltmeden sonra hatanın gerçekten gittiğini sınamak için de gerekir.
2. Ara değerleri yazdır. Şüpheli satırdan önce ve sonra değişkenlerin değerleri ekrana yazdırılır. Beklenen ile gerçek değerin ilk ayrıldığı yer, hatanın yeridir.
3. Kesme noktası koy. Hata ayıklayıcıda bir satıra kesme noktası (breakpoint) konur. Program o satıra gelince durur ve o andaki bütün değişkenler incelenir.
4. Adım adım ilerle. Program durduktan sonra satır satır ilerletilir. Her satırdan sonra hangi değerin değiştiğine bakılır.
5. Alanı daralt. Kodun yarısı geçici olarak devre dışı bırakılır ve hatanın hangi yarıda olduğu bulunur. Sonra o yarı yeniden ikiye bölünür. Yüz satırlık bir kodda hata yedi bölmede tek satıra iner, çünkü 2⁷ = 128 ≥ 100.
6. Anlatarak düşün. Kodu satır satır birine, hatta masadaki bir oyuncağa anlatmak çoğu zaman hatayı gösterir. Anlatırken “bu satır şunu yapıyor” denir ve bir anda satırın aslında başka bir şey yaptığı fark edilir.

Şekil 4.31 bir hata ayıklayıcının görünümünü taklit eder. Program 4. satırdaki kesme noktasında durmuştur ve henüz o satırı çalıştırmamıştır. Değişkenler panelinde üç not görünür. Satır ort ← n1 + n2 + n3 / 3'tür. “Adım” düğmesine basıldığında önce n3 / 3 = 30 hesaplanır, sonra 70 + 85 + 30 = 185. Ortalama 185 çıkar; beklenen değer ise 245 / 3 ≈ 81,67'dir. Hata ayıklayıcı, sorunun toplama değil bölme sırasında olduğunu bir bakışta gösterir.

4.7.2İzleyerek hata bulma

Aşağıdaki sözde kod üç sayının en büyüğünü bulmak için yazılmıştır. eb değişkeni “en büyük” değerini tutar:

oku a, b, c
eb ← 0
eğer a > eb ise eb ← a
eğer b > eb ise eb ← b
eğer c > eb ise eb ← c
yaz "En büyük: ", eb

İlk test için 7, 12 ve 5 seçilir; beklenen çıktı 12'dir. Tablo 4.19 programı izler.

Çıktı beklenenle aynıdır. Ama tek bir başarılı test programın doğru olduğunu kanıtlamaz. İkinci test bir sınır durumunu dener: sayıların hepsi negatif olsun, −5, −2 ve −9. Beklenen çıktı −2'dir (Tablo 4.20).

Üç karşılaştırmanın üçü de yanlıştır, çünkü hiçbir girdi 0'dan büyük değildir; eb hiç değişmez ve çıktı 0 olur (Şekil 4.32). Girdilerin hiçbiri 0 değildir. İzleme suçluyu gösterir: 2. satırdaki başlangıç değeri girdilerin dışından gelir. 0, “hiçbir sayıdan küçük olmayan” bir başlangıç değeri değildir; yalnızca pozitif sayılar için işe yarar.

Düzeltme, başlangıç değerini girdilerin birinden almaktır: eb ← a. eb artık bir girdiyle başladığı için sonuç her zaman girdilerden biri olur. a'nın kendisiyle karşılaştırılmasına da gerek kalmaz. Düzeltilmiş program Test 2 ile yeniden izlenir: eb = −5 ile başlar; −2 > −5 doğru, eb = −2; −9 > −2 yanlış. Çıktı −2'dir ✓. Bir düzeltmeden sonra önceki testlerin de yinelenmesi gerekir, çünkü düzeltme daha önce çalışan bir durumu bozmuş olabilir. Test 1 yeniden denenir ve yine 12 çıkar.

Aynı programın hatalı ve düzeltilmiş Java sürümleri aynı girdilerle çalıştırılmıştır:

import java.util.Scanner;

public class EnBuyukHatali {
    public static void main(String[] args) {
        Scanner giris = new Scanner(System.in);
        int a = giris.nextInt(), b = giris.nextInt(), c = giris.nextInt();
        int eb = 0;
        if (a > eb) eb = a;
        if (b > eb) eb = b;
        if (c > eb) eb = c;
        System.out.println("En büyük: " + eb);
    }
}

Girdi 7 12 5 ve −5 −2 −9 için çıktılar:

En büyük: 12

En büyük: 0

import java.util.Scanner;

public class EnBuyuk {
    public static void main(String[] args) {
        Scanner giris = new Scanner(System.in);
        int a = giris.nextInt(), b = giris.nextInt(), c = giris.nextInt();
        int eb = a;
        if (b > eb) eb = b;
        if (c > eb) eb = c;
        System.out.println("En büyük: " + eb);
    }
}

Düzeltilmiş sürüm aynı iki girdi ve eşit değerli bir girdi (3, 3, 1) için:

En büyük: 12

En büyük: -2

En büyük: 3

4.7.3Sık yapılan hatalar

Bazı hatalar o kadar sık yapılır ki adları vardır. Tablo 4.21 bunları örnekleri ve sonuçlarıyla listeler.

Başlangıç değeri hatasında diller farklı davranır. Java, değer verilmemiş bir yerel değişkenin okunmasına izin vermez:

public class Baslatilmamis {
    public static void main(String[] args) {
        int toplam;
        toplam = toplam + 5;
        System.out.println(toplam);
    }
}

Baslatilmamis.java:4: error: variable toplam might not have been initialized
        toplam = toplam + 5;
                 ^
1 error

C'de ise aynı kod derlenir. Değer verilmemiş yerel değişken, bellekte o anda ne varsa onu tutar ve program her çalıştırmada farklı bir sonuç verebilir. Java'nın katılığı burada bir korumadır: hatayı çalışma zamanından derleme zamanına taşır.

Sınır hatası (off-by-one error) en sinsi hatalardandır. 1'den n'ye kadar toplam isterken her i ← 1 … n − 1 için yazılırsa n atlanır. n = 5 için toplam 15 yerine 1 + 2 + 3 + 4 = 10 çıkar. Program çalışır, sonuç “makul” görünür ve hata kolayca gözden kaçar.

Bu hataların çoğu sınır durumlarıyla (edge cases) ortaya çıkar: 0, boş liste, en küçük ve en büyük değer, negatif sayı. Normal girdilerle çalışan bir program sınırlarda çoğu zaman bozulur. Bu yüzden her test kümesinde birkaç sınır durumu bulunmalıdır.

4.7.4Yazılım hatalarının bedeli

Bir ödevdeki hata düşük bir notla sonuçlanır. Gerçek sistemlerdeki hataların bedeli ise milyonlarca dolar, hatta insan hayatı olabilir. Üç ünlü örnek, bu notta anlatılan hata türlerinin gerçek dünyadaki karşılığını gösterir.

Ariane 5 (1996). Avrupa Uzay Ajansı'nın yeni roketi Ariane 5, ilk uçuşunda kalkıştan yaklaşık 37 saniye sonra rotasından saptı ve birkaç saniye içinde parçalandı. Soruşturma kurulunun raporuna göre neden bir sayı dönüşümüydü. Seyrüsefer yazılımı, 64 bitlik kayan noktalı bir yatay hız değerini 16 bitlik işaretli bir tam sayıya dönüştürüyordu. 16 bitlik işaretli bir tam sayı en fazla 32.767 değerini tutabilir. Yazılım daha yavaş tırmanan Ariane 4'ten alınmıştı ve orada bu sınır hiç aşılmamıştı. Ariane 5'in yatay hızı çok daha büyüktü, dönüşüm taşma hatası verdi ve seyrüsefer sistemi durdu.

public class Tasma {
    public static void main(String[] args) {
        double hiz = 40000.0;
        short kisa = (short) hiz;
        System.out.println(kisa);
        System.out.println(Short.MAX_VALUE);
    }
}

-25536
32767

Mars Climate Orbiter (1999). NASA'nın Mars'a gönderdiği sonda, yörüngeye girerken gezegene fazla yaklaştı ve kayboldu. Yer istasyonundaki bir yazılım iticilerin etkisini İngiliz birimiyle (pound-kuvvet·saniye) üretiyordu. Bu veriyi kullanan öbür yazılım ise metrik birim (newton·saniye) bekliyordu. 1 pound-kuvvet·saniye yaklaşık 4,45 newton·saniyedir. Bu yüzden itmenin etkisi yaklaşık 4,45 kat küçük hesaplandı ve yörünge hesabı dokuz aydan uzun süren yolculuk boyunca giderek kaydı. İki programın her biri tek başına doğru çalışıyordu; hata aralarındaki arayüzdeydi.

Therac-25 (1985–1987). Kanser tedavisinde kullanılan bir radyoterapi cihazının yazılımında bir zamanlama hatası vardı. Operatör ayarları belirli bir sırayla ve çok hızlı girdiğinde güvenlik denetimi atlanıyordu. Önceki modellerde bu denetimi donanım kilitleri de yapıyordu; Therac-25'te bu iş yalnızca yazılıma bırakılmıştı. 1985–1987 arasındaki altı kazada hastalar normalin çok üstünde radyasyon dozu aldı; en az üç hasta hayatını kaybetti.

Üç hata da derleyicinin yakalayamayacağı türdendir. Biri bir sınır durumu, biri birim tutarsızlığı, biri zamanlamaya bağlı bir mantık hatasıdır. Ortak ders birkaç maddede toplanır. Sınır durumları denenmeli, birimler değişken adlarında ve belgelerde açıkça yazılmalıdır. Bir sistemden alınan yazılım, yeni sistemin koşullarıyla yeniden sınanmalı ve kod bir başkasına incelettirilmelidir.

4.7.5Okunabilir kod

Kod bir kez yazılır, defalarca okunur. Onu haftalar sonra yazanın kendisi, ekip arkadaşları ve bakımı devralan başkaları okur. Okunabilir kod hataları hem önler hem de bulunmalarını kolaylaştırır. Aşağıdaki iki sözde kod aynı işi yapar.

Çalışır ama okunmaz:

a ← oku()
b ← oku()
c ← a*b/2
yaz c

Aynı program, okunur:

// üçgenin alanı = taban × yükseklik / 2
taban ← oku()
yukseklik ← oku()
alan ← taban × yukseklik / 2
yaz "Alan: ", alan

İlk programı okuyan, c'nin ne olduğunu anlamak için formülü çözmek zorundadır; a*b/2 bir üçgen alanı olabilir, bir ortalama hesabının yanlış yazılmış hâli de olabilir. İkinci program kendini anlatır. Aradaki farklar şunlardır:

• Anlamlı adlar. c yerine alan, a yerine taban yazılır. Okuyan kişi değişkenin rolünü adından anlar.
• Tutarlı girinti ve boşluk. İşlemlerin çevresindeki boşluklar ve iç içe blokların düzenli girintisi, yapının sınırını bir bakışta gösterir.
• Sihirli sayı yerine adlandırılmış sabit. Kodun içine gömülü, anlamı açıklanmamış sayıya sihirli sayı (magic number) denir. fiyat * 0.20 yerine KDV_ORANI ← 0.20 tanımlanır ve fiyat * KDV_ORANI yazılır. Oran değiştiğinde tek bir satır düzeltilir.
• Tekrarı fonksiyona taşımak. Aynı formül üç yerde yazılıysa bir düzeltmenin üç kez yapılması gerekir ve biri mutlaka unutulur.
• Açıklama satırı. Açıklama kodun ne yaptığını değil, neden yaptığını anlatır. // x'e 1 ekle açıklaması kodu tekrar eder ve bir şey katmaz. // dizi 0'dan başlıyor, sıra numarası için 1 ekle açıklaması ise bir niyeti açıklar.

import java.util.Scanner;

public class UcgenAlani {
    public static void main(String[] args) {
        Scanner giris = new Scanner(System.in);
        // üçgenin alanı = taban × yükseklik / 2
        double taban = giris.nextDouble();
        double yukseklik = giris.nextDouble();
        double alan = taban * yukseklik / 2;
        System.out.println("Alan: " + alan);
    }
}

Alan: 15.0

Alan: 10.5

public class KDV {
    static final double KDV_ORANI = 0.20;

    public static void main(String[] args) {
        double fiyat = 250.0;
        double kdv = fiyat * KDV_ORANI;
        System.out.println("KDV: " + kdv);
        System.out.println("Toplam: " + (fiyat + kdv));
    }
}

KDV: 50.0
Toplam: 300.0

4.8Özet

• Programlama dili, algoritmayı bilgisayarın yürütebileceği biçimde ifade eden biçimsel bir dildir. Söz dizimi neyin yazılabileceğini, anlam yazılanın ne yaptığını belirler. Söz dizimi doğru bir program yanlış iş yapabilir.
• Kaynak kod insanın okuduğu metindir; makine dili işlemcinin çalıştırdığı ikili komutlardır; assembly makine komutlarının simgesel yazılışıdır. Yüksek seviyeli bir satır çoğu zaman birkaç makine komutuna karşılık gelir.
• Kaynak kod üç yolla çalıştırılır. Derlenen dillerde (C) program önceden makine koduna çevrilir. Yorumlanan dillerde (Python) komutlar çalışma sırasında değerlendirilir. Hibrit dillerde (Java) kaynak kod bytecode'a derlenir ve bytecode bir sanal makinede (JVM) yürütülür. JIT derleyici sık çalışan kodu çalışma sırasında makine koduna çevirir. Derlenen/yorumlanan ayrımı dilin değil, uygulamanın özelliğidir.
• Hatalar üç türdür. Derleme hatası çeviri sırasında bulunur, program hiç çalışmaz. Çalışma zamanı hatası yürütme sırasında programı durdurur. Mantık hatası hata iletisi vermez, yanlış sonuç üretir ve ancak test ile bulunur.
• Derleyici beş aşamada çalışır: sözcük çözümleme (belirteçler), söz dizimi çözümleme (söz dizimi ağacı), anlam çözümleme (adlar ve tipler), ara kod ve iyileştirme (ör. sabit katlama), kod üretimi. İlk üç aşama hata arar. Bağlayıcı nesne dosyalarını ve kütüphaneleri birleştirir, yükleyici programı belleğe alıp başlatır.
• Diller seviyeye (düşük: makine dili, assembly; yüksek: C, Java, Python), türe (genel amaçlı, alana özgü, betik, işaretleme) ve paradigmaya (buyurgan, nesne yönelimli, fonksiyonel) göre sınıflandırılır. Seviye bir kalite ölçüsü değil, soyutlama düzeyidir. Dil seçimini problem alanı, platform, kütüphaneler, performans, güvenlik ve ekip deneyimi belirler.
• Statik tiplemede (Java) tip hataları derleme sırasında, dinamik tiplemede (Python) ilgili satır çalıştığında bulunur.
• Problemden programa giden yol: problemi tanımla (girdi, çıktı, kısıt), elle örnek çöz, algoritmayı kur, koda dönüştür, test et. Test bir eksik bulursa önceki aşamaya dönülür.
• Yazılım geliştirme süreci gereksinim, tasarım, kodlama, test, dağıtım ve bakımdan oluşan yinelemeli bir süreçtir. Şelale modeli aşamaları bir kez ve sırayla geçer. Çevik yaklaşım kısa döngülerle ilerler. Prototipleme belirsiz gereksinimi görünür kılar. IDE, derleyici, hata ayıklayıcı, sürüm kontrolü, test araçları ve paket yöneticisi bu sürecin araçlarıdır.
• Değişken, karar, döngü, fonksiyon ve dizi temel programlama yapılarıdır. İşlem önceliği matematikteki gibidir. Döngünün bitmesi için gövdenin koşulu etkilemesi gerekir. Her fonksiyon çağrısı çağrı yığınında kendi çerçevesini açar. Dizi indisleri 0'dan başlar, son indis uzunluk − 1'dir.
• Hatalar sınır durumlarıyla (0, boş liste, negatif sayı, en küçük ve en büyük değer) test edilerek ve program izleme tablosuyla adım adım izlenerek bulunur. Okunabilir kod (anlamlı adlar, adlandırılmış sabitler, fonksiyonlar, “neden” anlatan açıklamalar) hataları hem önler hem de bulunmalarını kolaylaştırır.

4.9Kavram listesi

Terimlerin İngilizce karşılıkları ve öteki sunumlardaki kullanımları terim sözlüğünde bulunur.

• programlama dili programming language
• söz dizimi syntax
• anlam semantics
• kaynak kod source code
• makine dili machine language
• makine kodu machine code
• assembly assembly language
• çeviri aracı translator
• derleyici compiler
• derleme compilation
• yorumlayıcı interpreter
• yorumlama interpretation
• derlenen / yorumlanan compiled / interpreted
• bytecode (ara kod) bytecode
• ara kod intermediate code
• sanal makine virtual machine
• Java Sanal Makinesi (JVM) Java Virtual Machine
• JIT (tam zamanında) derleyici just-in-time compiler
• derleme hatası compile error
• söz dizimi hatası syntax error
• çalışma zamanı hatası runtime error
• mantık hatası logic error
• sözcük çözümleme lexical analysis
• belirteç token
• söz dizimi çözümleme parsing
• söz dizimi ağacı syntax tree
• anlam çözümleme semantic analysis
• kod iyileştirme code optimization
• sabit katlama constant folding
• nesne dosyası object file
• bağlayıcı linker
• bağlama hatası linking error
• yükleyici loader
• çalıştırılabilir dosya executable file
• sınıf yükleyici class loader
• yüksek / düşük seviyeli dil high-level / low-level language
• alana özgü dil domain-specific language
• betik dili scripting language
• işaretleme dili markup language
• programlama paradigması programming paradigm
• buyurgan yaklaşım imperative programming
• nesne yönelimli object-oriented
• fonksiyonel functional programming
• statik tipleme static typing
• dinamik tipleme dynamic typing
• şelale modeli waterfall model
• çevik agile
• prototipleme prototyping
• IDE integrated development environment
• hata ayıklayıcı debugger
• kesme noktası breakpoint
• paket yöneticisi package manager
• sürüm kontrolü version control
• kayıt commit
• dal branch
• birleştirme merge
• çakışma merge conflict
• veri tipi data type
• işlem önceliği operator precedence
• sonsuz döngü infinite loop
• parametre parameter
• argüman argument
• çağrı yığını call stack
• dizi array
• indis index
• kütüphane library
• API (uygulama programlama arayüzü) application programming interface
• sınır hatası off-by-one error
• sihirli sayı magic number

4.10Kendini Dene

1. Aşağıdaki Java hatalarının her biri hangi türdendir? Derleme hatasıysa derleyicinin hangi aşamasında yakalanır? (a) System.out.println("Merhaba); (b) Bildirilmemiş toplam değişkenini kullanmak. (c) n öğeli bir dizide i <= n koşuluyla dönen döngü. (d) Ortalamayı hesaplarken toplamı n − 1'e bölmek.

   Cevap

   (a) Derleme hatasıdır; kapanmamış dizgi bir belirtece dönüştürülemediği için sözcük çözümleme aşamasında yakalanır (javac: “unclosed string literal”). (b) Derleme hatasıdır; adın bildirilip bildirilmediğine anlam çözümleme aşamasında bakılır (“cannot find symbol”). (c) Çalışma zamanı hatasıdır; son turda i = n olur ve dizi[n] dizinin dışındadır, Java ArrayIndexOutOfBoundsException verir. (d) Mantık hatasıdır; program her girdiyle çalışır ama ortalamayı olduğundan büyük bulur.

2. Üç satırlık bir Python dosyası şöyle: print("A"), print(1 / 0), print("B" (son satırda parantez kapanmamış). Dosya çalıştırılınca ekranda ne görünür? Satır satır çalışan basit bir yorumlayıcı ne gösterirdi?

   Cevap

   Python çalıştırmaya başlamadan önce dosyanın tamamını ayrıştırır. Üçüncü satırdaki kapanmamış parantezi bulur ve yalnızca SyntaxError: '(' was never closed iletisini verir. “A” yazılmaz, sıfıra bölmeye hiç ulaşılmaz. Satır satır çalışan basit bir yorumlayıcı ise önce “A” yazar, ikinci satırda sıfıra bölme hatasıyla durur; üçüncü satırdaki söz dizimi hatasını hiç görmez.

3. toplam = toplam + 1; satırı sözcük çözümlemede kaç belirtece ayrılır? Belirteçlerin türleri nelerdir?

   Cevap

   Altı belirteç: toplam (tanımlayıcı), = (operatör), toplam (tanımlayıcı), + (operatör), 1 (sabit değer), ; (ayırıcı). Boşluklar atılır. Aynı ad iki kez geçtiği için iki ayrı belirteç olarak sayılır.

4. Aşağıdaki sözde kod ne yazar? Gövde kaç kez çalışır, koşul kaç kez denetlenir? s ← 0; i ← 1; i ≤ 4 iken tekrarla: s ← s + i × i; i ← i + 2; yaz s.

   Cevap

   1. tur: 1 ≤ 4 doğru; s = 0 + 1 × 1 = 1, i = 3. 2. tur: 3 ≤ 4 doğru; s = 1 + 3 × 3 = 10, i = 5. Denetim: 5 ≤ 4 yanlış, döngü biter. Ekrana 10 yazılır. Gövde 2 kez çalışır, koşul 3 kez denetlenir. Çarpma toplamadan önce yapıldığı için s + i × i ifadesinde parantez gerekmez.

5. fonksiyon f(x): döndür 2 × x + 1 tanımlı. yaz f(f(2)) ne yazar? Kaç çerçeve açılır, ikisi aynı anda yığında bulunur mu?

   Cevap

   Önce içteki çağrı çalışır: f(2) için bir çerçeve açılır, x = 2, 2 × 2 + 1 = 5 döndürülür ve çerçeve kapanır. Sonra dıştaki çağrı f(5) için yeni bir çerçeve açılır: 2 × 5 + 1 = 11. Ekrana 11 yazılır. İki çerçeve açılır ama aynı anda yığında bulunmaz: dıştaki çağrı, argümanı hesaplanıp içteki çerçeve kapandıktan sonra başlar.

6. Java'da int s = 17 % 5 * 2 + 9 / 2; satırından sonra s kaçtır? Hesaplama sırasını yazın.

   Cevap

   %, * ve / aynı öncelik düzeyindedir ve toplamadan önce, soldan sağa yapılır. 17 % 5 = 2, 2 × 2 = 4. Ardından 9 / 2 iki tam sayının bölümü olduğu için 4'tür (4,5 değil). Son olarak 4 + 4 = 8. s = 8 olur.

7. Bir Python fonksiyonu x 10'dan büyükse "a" + 5 döndürüyor, değilse "küçük". Program mesaj(3) ve ardından mesaj(20) çağrılarını yapıyor. Hata ne zaman ortaya çıkar? Aynı mantık Java'da yazılsaydı ne olurdu?

   Cevap

   Python dosyayı sorunsuz ayrıştırır, çünkü söz dizimi doğrudur. mesaj(3) “küçük” döndürür ve yazılır. mesaj(20) çağrısında hatalı satır ilk kez çalışır ve TypeError verir. Dinamik tiplemede tip hatası ancak satır çalışınca görülür; x hiç 10'u geçmeseydi hata hiç görülmezdi. Java'da dönüş tipi String olan bir metotta "a" + 5 dizgi birleştirmedir ve geçerlidir: “a5” döndürür. Dönüş tipi int olsaydı derleyici tip uyuşmazlığını program hiç çalışmadan bildirirdi.

8. Bir dizinin en küçük öğesini bulmak için ek ← 0 ile başlayan ve her öğeyi eğer d[i] < ek ise ek ← d[i] ile karşılaştıran bir program yazılmış. d = [3, 8, 1, 6] için çıktı nedir? Hata nedir, nasıl düzeltilir?

   Cevap

   Dört karşılaştırmanın hiçbiri doğru değildir: 3, 8, 1 ve 6'nın hiçbiri 0'dan küçük değildir. ek hiç değişmez ve çıktı 0 olur; doğru sonuç 1'dir. Hata başlangıç değerindedir: 0, girdilerin dışından gelen bir değerdir ve pozitif sayılar için en küçük değer gibi davranır. Düzeltme ek ← d[0]'dır. İzleme: ek = 3; 8 < 3 yanlış; 1 < 3 doğru, ek = 1; 6 < 1 yanlış. Çıktı 1 olur.

4.11İleri okuma

• A. B. Downey, C. Mayfield, Think Java (2. baskı, O'Reilly, 2019): Java ile programlamaya giriş; ilk bölümleri derleme, yorumlama, hata türleri ve hata ayıklamayı bu nottaki düzeyde anlatır. Green Tea Press sitesinde ücretsiz okunabilir.
• R. Sedgewick, K. Wayne, Computer Science: An Interdisciplinary Approach (Addison-Wesley, 2016): Java ile programlamayı bilim ve mühendislik örnekleri üzerinden öğretir; değişken, döngü, fonksiyon ve diziler için bol örnek içerir.
• R. W. Sebesta, Concepts of Programming Languages (12. baskı, Pearson, 2019): dillerin tarihçesini, söz dizimi ve anlamın tanımlanmasını, tip sistemlerini ve paradigmaları ayrıntılı karşılaştırır.
• A. V. Aho, M. S. Lam, R. Sethi, J. D. Ullman, Compilers: Principles, Techniques, and Tools (2. baskı, Addison-Wesley, 2006): derleyicinin aşamalarını anlatan temel kaynak; sözcük çözümleme, söz dizimi çözümleme ve kod iyileştirme konularını derinleştirmek isteyenler için.

4.12Kaynaklar

1. R. W. Sebesta, Concepts of Programming Languages, 12. baskı, Pearson, 2019.
2. A. V. Aho, M. S. Lam, R. Sethi, J. D. Ullman, Compilers: Principles, Techniques, and Tools, 2. baskı, Addison-Wesley.
3. R. Sedgewick, K. Wayne, Computer Science: An Interdisciplinary Approach, Addison-Wesley, 2016.
4. A. B. Downey, C. Mayfield, Think Java, 2. baskı, O'Reilly, 2019 (ücretsiz çevrim içi sürüm).
5. Oracle, The Java Tutorials: Getting Started.

İlgili sayfalar: Programlamaya Giriş sunumu · Çalışma soruları · Java derleme ve çalıştırma simülatörü · Terim sözlüğü · © Sercan Külcü. Tüm hakları saklıdır.