Günümüzde kullandığımız telefonlar, bilgisayarlar, bunların içindeki uygulamalar, arabalar ve hatta beyaz eşyalar bile birinin yazdığı ve bir şekilde çalışan kodlar sayesinde çalışıyor. Bizim bir dosyaya yazdığımız kodları bir çıktıya dönüştüren programlar bile var ki bunlara “programlama dili” diyoruz. Ama bu nasıl oluyor diye hiç düşündünüz mü? “Programlama dilleri nasıl çalışıyor?” diye ilk düşündüğümde bu iş sanki imkansız gibi hissetmiştim. Sanki bu dilleri sihirli birer araçtı. Benim yazdığım bir koddan programın çıktısına kadar nasıl varıldığını anlamak için bir yolculuğa çıktım ve size bu yolculuğun bir özetini sunmak istiyorum. Bu yazıda yazdığımız bir programın bize sonuç üretilene kadar geçtiği aşamaları anlatarak sizleri aydınlatmayı amaçlıyorum. Fakat bu fikirlerin nasıl uygulandığı konusuna girmeyeceğim çünkü her bir aşama için birçok farklı yöntem bulunmaktadır ve bunların anlatılması yazıyı gereksiz uzatarak dikkat dağınıklığına neden olacaktır. Yine de eğer konular ilginizi çekerse araştırmanızı öneririm.
Programlama Dillerinin Türleri
Programlama dilleri pek çok kritere göre sınıflandırılır. Bu yazıda dikkatinizi dillerin çalıştırılma yöntemine göre sınıflandırılmasına çekmek istiyorum. Programlama dilleri bu açıdan iki kategoriye ayrılır: yorumlanan (interpreted) ve derlenen (compiled). Yorumlanan diller, interpreter denen yazılımlar ile, dosyaların çalışma zamanında işlenmesi ile çalıştırılır; derlenen diller ise compiler denen yazılımlar aracılığı ile çalıştırılabilir bir forma (C gibi diller için bu form makine kodu iken Java gibi diller için bu bytecode’dur) dönüştürüldükten sonra çalıştırılır. Bizim bu yazıdaki sorumuzu cevaplamak için incelememiz gereken ise interpreter ve compiler’ların yaptıkları. Yazı boyunca compiler kelimesini aynı anda hem derleyici hem de yorumlayıcı anlamına gelecek şekilde kullanacağım çünkü çalıştırma bölümünde de bahsedeceğim gibi her ikisi de günümüzde neredeyse aynı hale gelmiştir.
Lexer: Ön İşlem
İnanın bana, dosyadaki yazıları doğrudan çalıştırmayı denemek oldukça zor olacaktır. Onun yerine daha derli toplu bir bilgi alsaydık koddan anlam çıkarmak çok daha kolay olurdu. İşte bir compiler’ın metin halindeki kodu daha bilgisayar dostu bir formata çeviren ilk aşamasına lexer diyoruz. Sindirim sisteminde ağız ne ise compiler için lexer odur diyebiliriz. Ağızın büyük bir besini küçük parçalara bölüp bazı kimyasallarla birleştirdiği gibi, bir lexer da metini token’lara çevirip bu token’lara birkaç kullanışlı bilgi ekler. Peki bir token, içinde genellikle hangi bilgileri barındırır? Token türü (number, identifier, operator, . . . ) ve içeriği (mesela number ise 1618 mi 3.14 mü) bir compiler için vazgeçilmez bilgilerdir. Bunun yanında satır ve sütun bilgisini de alırsak bir hata oluşursa yerini kullanıcıya iletirken işimiz çok daha kolay olacaktır.
Bir örnek ile lexer’dan alacağımız token listesinin neye benzeyeceğine bakalım.
// hesaplama var a = 1 + 2 * 3 - 4;
Bu koddan oluşacak lexer çıktısının şu şekilde olması beklenir:
Token(keyword_var, "", line=2, col=1) Token(identifier, "a", line=2, col=5) Token(op_equal, "=", line=2, col=7) Token(number, "1", line=2, col=9) Token(op_plus, "+", line=2, col=11) Token(number, "2", line=2, col=13) Token(op_mult, "*", line=2, col=15) Token(number, "3", line=2, col=17) Token(op_minus, "-", line=2, col=19) Token(number, "4", line=2, col=21) Token(semicolon, ";", line=2, col=22)
Burada dikkatinizi çekmek istediğim bir nokta da yorumların ve boşlukların elenmesi. Python gibi boşluk karakterlerine dikkat eden bir dilin lexer’ı bu bilgiyi de token olarak vermeli.
Parser: Anlamlandırma
Yazılmış kodun ne anlama geldiğini bulmadan kodu çalıştıramayız. Artık daha uygun formattaki bilgileri kullanarak kodun anlamını bulabiliriz.
Anlam derken ne demek istediğimi şöyle açıklayayım. Anlam, bir matematiksel ifadedeki işlem önceliğini de içinde barındırır, bir fonksiyonun uygulayacağı adımları da. Bir değişken gördüğünde o değişkene atama mı yapılıyor, yoksa onun değeri mi kullanılacak olduğunu söyler. Bir kontrol yapısının neresinin koşul, neresinin gövde olduğunu belirtir.
Compiler’ın bize bu bilgiyi verecek olan parçasına parser denir. Parser belirli kurallar ile kendisine gelen token listesini analiz eder. Örneğin bu şekilde tanımlanmış kurallar, işlem önceliğine göre matematiksel ifadeleri anlamlandırır.
<expression>
: <term>
| <expression> token_plus <term>
| <expression> token_minus <term>
;
<term>
: <unary>
| <term> token_mult <unary>
| <term> token_div <unary>
;
<unary>
: <primary>
| token_minus <unary>
;
<primary>
: "(" <expression> ")"
| token_number
| token_identifier
;
Fakat kodu anlamlandırdığımız gibi çalıştıramayız. Önce bütün programın tamamı parser’dan geçmeli. Çünkü fonksiyon tanımı gibi program parçaları yazıldığı yerden başka yerlerde çalıştırılır, koşul ifadelerinin çalışmaması gerekebilir ve döngüler birden fazla kez çalışabilir. Peki programın anlamını nasıl hafızada tutuyoruz? Abstract Tree (AST) adı verilen bir ağaç yapısı bize yardımcı oluyor. Bu ağacın her node’u programlama dilinin yapacağı bir eylemi temsil eder ve bu eylem için gerekli parçaları bir arada tutar. Örneğin değişken atama işlemini temsil eden bir node hangi değişkene atanacağı ve hangi ifadenin atanacağını içerir. Matematiksel ifadeler de bu ağaçta işlem önceliğine göre organize edilir. Önce yapılacak işlem ağaçta daha derinde bulunur, böylece bu işlemin sonucu daha sonra yapılacak işleme aktarılabilir. Mesela daha önceki örneğimizde token’larına ayırdığımız kodun AST’si şu şekilde olacaktır.
Ya da bir döngüyü ifade eden AST’de döngünün koşulu ve döngünün yapacağı işler (döngünün gövdesi) tutulur.
while (i < 10) {
print(i);
i = i + 1;
}
Parser’ın ürettiği AST ile birlikte artık kodun anlamını biliyoruz. Artık kodu çalıştırabiliriz.
Çalıştırma
Lexer ve parser’ların çalışması, compiler’lar ve interpreter’ler için neredeyse aynıdır. İkisinin arasındaki fark bu aşamada ortaya çıkmaya başlar. Bu yolda izleyebileceğimiz en ilkel çözüm, ürettiğimiz AST’yi direk olarak yorumlamak olur. Buna tree-walk interpreter denir.
Tree-walk Interpreter
Bu yöntemde parser’dan aldığımız tree yapısını depth first traversal’a benzer bir şekilde dolaşırız. Matematiksel ifadeler bu şekilde kolayca değerlendirilir. Bir değişkene atama yapacağımız zaman bir hashmap ile kaydını tutup gerektiği zaman değişkenin değerini buradan alabiliriz. Bir koşul yapısına geldiğimizde ilk önce koşulu kontrol ederek sadece doğru subtree’yi ziyaret ederiz. Bir döngü yapısında da koşul yanlışa dönene kadar döngü içindeki kodu çalıştırabiliriz.
Kodlaması çok basit olmasına rağmen bu yöntem dilin çalışma zamanını ve hafıza kullanımını diğer yöntemlere göre çok artırır. Eskiden daha yaygın kullanılan bu yöntem (Lisp, Basic, Ruby gibi dillerin eski versiyonları örnek verilebilir), şimdilerde neredeyse sadece eğitim amaçlı kullanılıyor.
Ahead of Time Compilation
Bu yöntem ise AST’nin dolaşılarak direk makine koduna dönüştürülmesine ve üretilen çıktı dosyasının çalıştırılmasına dayanır. Bu yöntem tree-walk interpreter’a göre çok daha karmaşıktır ama karşılığında ulaşabileceğimiz en hızlı çalışma zamanını elde ederiz (örneğin C/C++, Go, Rust).
Bytecode Interpreter
Bu yöntemde ise programlama dili AST’yi bytecode adı verilen dile özgü bir formata çevirir ve ardından yine dile özgü bir sanal makine ile bu kod çalıştırılır. Tree-walk interpreter’e göre performans açısından çok daha iyidir ve ahead of time’a göre (CPU’yu düşünmeye gerek kalmadığı için) kodlaması çok daha kolaydır. Günümüzde pek çok dil bu yöntemi kullanarak çalışır. Bu yöntem interpreter ve compiler yazımı arasındaki farkı oldukça azaltmıştır.
Kapanış
Bu yazıda yazdığımız bir kodun hangi aşamalardan geçerek çalıştırıldığını elimden geldiğince anlatmaya çalıştım. Umarım sizler de bir kodun geçirdiği yolculuktan keyif almışsınızdır. Ve umarım sizin için programlama dilleri ile ilgili sır perdesini aralayabilmişimdir.
Yorumlar
Beğenmek ya da yorum yazmak için GitHub hesabıyla giriş yapmanız gerekir.