Programlama Dillerinin Gelişimi – IV

Bilgisayar Bilimleri , , , , , ,

Konu ile alakalı olarak daha önce yazdığım 3 yazıda, programlama dillerinin gelişimini sadece yordamsal ve nesne-merkezli dillerin üzerinden ele aldım. Tabi ki bu yaklaşım eksiktir. Çünkü böyle bir yaklaşım, programlamanın fonksiyonel (functional) ve mantıksal (logical) olan diğer iki paradigmasını yok saymaktadır. Böyle bir yaklaşıma iki sebep öne sürebilirim: İlki, atladığım bu iki yaklaşımın, genel amaçlı programlama dilleri dünyasında çok da yaygınlık bulamamış olmalarıdır. Bu yaklaşım çerçevesinde geliştirilen Haskell ya da Lisp gibi diller daha çok özel uygulamalarda, örneğin Lisp için AI, başarılı olup, genel uygulama geliştirme amacıyla pek kullanılmamışlardır. Diğeri sebebim ise bu yaklaşımlarda çok da bilgili olmamamdır.

[openbook booknumber=”9780136073475″ templatenumber=”1″]

BT’nin en temel faaliyeti olan programlama için ortaya çıkan 4 farklı (yordamsal (emperative ya da procedural), fonksiyonel (functional), mantıksal (logical) ve nesne-merkezli, (object-oriented)) yaklaşımı, tarihi serencamlarını ve bu yaklaşımların temel özelliklerini dillerle örnekleyen Sebesta’nın “Concepts of Programming Languages” isimli kitabı güzel bir kaynaktır. Her ne kadar kitabın büyük çoğunluğu yordamsal dillere ağırlık verse de çok güzel tarihi bilgilerle doludur.

Ayrıca http://www.levenez.com/lang/ adresinde programlama dillerinin tarihiyle alalakı güzel bilgiler var. Yine burada, programlama dillerini kronolojisi büyükçe bir kitapçık olarak verilmektedir. Bu kitapçıktan yola çıkarak O’Reilly yayınevi konuyla ilgili bir çalışma yaptı ve bir poster yayınladı.

Konuyla alakalı olarak aşağıdaki kaynaklardan faydalanabilirsiniz:

 

Toplam görüntülenme sayısı: 937

Programlama Dillerinin Gelişimi – III

Bilgisayar Bilimleri

Nesne-Merkezli Diller

1965’te çıkan SIMULA I ile 1967’de çıkan SIMULA67, ilk nesne-merkezli dillerdir. Oslo’daki Norveç Bilgisayar Merkezi’nde (Norwegian Computing Center) Kristen Nygaard ve Ole-Johan Dahl tarafından geliştirilen bu diller, modern nesne yapılarını ihtiva etmekteydiler.

Simula (Simulation Language) dilleri, adından da anlaşılacağı gibi daha çok fiziksel sistemlerin simulasyonlarını başarıyla gerçekleştirebilmek amacıyla geliştirilmişlerdir. Bu dilleri geliştirenler, bilgisayarlı simulasyon projeleri için kullanmak üzere, var olan dillerin yerine, işlerinde ortaya çıkan modelleri karşılayacak şekilde tasarlanmış yeni bir dile ihtiyaçlarının olduğunu düşündüler. Ve bu amaçla Algol dillerini temel alarak Simula dillerini geliştirdiler. Algol dilleri, ilk versiyonu 1950’li yıllarda geliştirilen Algol58 ve 60’larda daha yapısal hale getirilen Algol60 ve Algol68’den oluşmaktadır. Bu dillerin ortaya çıkardığı pek çok yapı, modern yordamsal dillerde devamlı olarak kullanılmıştır. Özellikle Algol68’de uygulanan, fonksiyonlar için, isimle-geçme (pass-by-name) ya da değerle-geçme (pass-by-value) gibi farklı parametre geçme yöntemleri, bloklu yapılar (block-structured) ve dolayısıyla da etkinlik alanı (scope)  kavramı, kendini çağırabilen (recursive) fonksiyonlar gibi pek çok yapı, daha sonra geliştirilen, yordamsal olsun olmasın, pek çok dilin en temel özelliklerini oluşturmuştur.

Simula dillerinden önce Simula I, ayrık olay simulasyonu (discrete-event simulation) için geliştirilmiş, daha sonra da daha yetenekli hali olan Simula67 ortaya çıkmıştır. Simula67, sınıf (class), nesne (object), alt sınıf (subclass), sanal metot (virtual method), eş-rutin (coroutine) ve çöp toplama (garbage collection) gibi yapılara sahipti. Bu dili geliştirenler, önce üzerinde çalıştıkları bir projede gemileri, birden fazla özelliği bir araya getirerek ifade etme ihtiyacı ile karşılaştılar. Daha sonra da farklı tipte gemilerin ortak ve farklılaşan taraflarını ifade etme ihtiyacı önlerine çıktı. Onlar da farklı gemi türlerini kavramsal olarak farklı sınıflarda ifade edip, gerçek olan gemileri ise bu sınıfların birer örneği (instance) ya da nesnesi olarak oluşturdular.

Sınıf ve nesne kavramının, böyle bir fiziksel olguyu matematiksel olarak betimlemek ihtiyacı için çıkmış olması hiçbir şekidle tesadüfi değildir. Aksine bu gelişme, laboratuvarlardan dışarı çıkan ve gündelik hayatın farklı yönlerini modellemek durumunda olan bir dilin nasıl bir ihtiyaç içinde olacağını göstermesi açısından çok manidardır. Bu durumu belki biraz daha iddalı olarak şöyle açıklayabiliriz: Programlama dilleri zaten soyut yapılardır ve ilk yıllarından itibaren, üzerinde çalışılan makinanın donanımıdaki karmaşıklıkları geride bırakıp, bize, bu yapıları daha kolay kullanabilmemizi sağlayan, daha soyut komutlarla yüksek seviyeli program geliştirme imkanı vermişlerdir. Fakat temelde yaptıkları, makinayı yani donanımı modellemektir. Nesne ise, gerçek hayatın, içinde yaşadığımız dünyanın bir kavramıdır. Dolayısıyla nesne-merkezli dillerin en temel özelliği makinayı değil, problem alanını modellemeleridir. Dolayısıyla nesneler ile, ihtiyaçların, zorlamalar olmadan, aslına uygun bir şekilde ifade edilmesi mümkün hale gelmiştir. Yordamsal diller, gerçekliği makina seviyesinin hemen üzerindeki soyutlamalarla ifade etme gücü vermişti bize ve bu ciddi bir ilerlemeydi. Fakat en temel problemi, halen makina odaklı düşünmemize sebep olması ve dolayısıyla da bizi, problemleri algoritmik olarak, ardışıl matematiksel yapılarla ifade etmek zorunda bırakmasıydı. Fakat nesne-merkezli diller bizi, makina yerine gerçek probleme odaklar; çözmeye çalıştığımız problemi, nesne kavramı etrafında modellemeye iter. Yazılım geliştirmeyi, problem alanından çözüm alanına bir dönüşüm (transformation) olarak görürsek, önemli olan şeyin, problem alanının doğru bir şekilde yakalanması ve ifade edilmesi olduğunu anlarız. Programlama dilinde modellenen gerçekliğin makina yapılarına dönüştürülmesi ise arka planda, derleyici ve yorumlayıcıların görevi olmalıdır. Böyle bir ortamda yazılımcılar, gerçekliği ifade etmek için çok daha tabii ve sağlıklı bir mekanizmaya sahip olurlar.

Simula dilleri her ne kadar pratik olarak çok geniş bir kullanım alanı bulmamış olsalar da, özellikle Simula67, gerek Smalltalk gerek ise C++ gibi iki ana nesne-merkezli dilin gelişmesine öncülük etmiştir.

Smalltalk, 70’li yılların başlarında, Alan Kay önderliğindeki bir grup tarafından Xerox’un Palo Alto Araştırma Merkezi’nde geliştirilmiştir. Aslında Smalltalk bir dil ailesinin ismidir ve özellikle de 80’li yıllarda bu isim altında çeşitli Smalltalk dilleri geliştirilmiştir. Fakat buna rağmen, genelde Smalltalk denince akla Smalltalk-80 gelir.

Smalltalk, “Herşey bir nesnedir” (Everything is an object) paradigması üzerine bina edilmiştir. Smalltalk’da, Simula’nın bulduğu nesne soyutlaması olan sınıf bile bir nesnedir. Nesneler arası haberleşme ise, nesnelerin birbirlerine mesaj göndermeleriyle gerçekleşir.

Smalltalk sadece bir diğer dil olarak ortaya çıkmadı; Smalltalk, yoğun grafik kullanıcı arayüzlerine (GUI, Graphical User Interface) sahip ilk geliştirme ortamı sunan dildi. GUI, masaüstü kavramı ve fareyi (mouse) dünyamıza katan Xerox Palo Alto Araştırma Merkezi’ndeki ilk GUI sistemi, Alan Kay ve bir grup araştırmacı tarafından geliştirilmiştir. (GUI teknolojisini Xerox’tan alıp geliştiren Steve Jobs, 1984 yılında piyasaya çıkardığı Macintosh ile bir GUI kullanan ilk ticari sistemi kullanıma açmış oldu.)

Nesne-merkezli dillerin nesnesi en temelde bir soyut veri yapısıdır. Yani nesne, davranışları ve o davranışların kullanacağı ortak veri yapılarını sınıf (class) denilen bir yapıda bohçalar ya da sarmalar (encapsulation) öyleki iç yapılarını saklayarak (information hiding), arayüzündeki metodlar (interface) yoluyla dışarıya hizmet verir. İç yapısını dışarıdan saklamak amacıyla nesne-merkezli dillerde erişim kontrolü sağlayan yapılar (access modifiers) bulunur. Nesnenin iç yapısını saklayıp, diğer nesnelerle ilişkilerini arayüzü yani hizmet vermeyi vadettiği metotlar üzerinden kurması, nesne ile diğer nesneler arasındaki bağımlılığı (dependency ya da coupling) daha aza indirir.

Bütün bunlardan sonra nesne-merkezli dillerin en temel iki özelliğini, gerçekliği olabildiğince aslına uygun olarak resmetmek ve yazılımların rahatça değişebilmelerini sağlamak olarak özetleyebiliriz.

Tarihi olarak nesne-merkezli yaklaşımın ana programlama paradigması olması, ilk nesne-merkezli diller olan Simula ve Smalltalk’ın zamanından çok sonra, Java ile gerçekleşmiştir. Aslında nesnelerle alakalı pek çok yapı 80’li yıllarda teorik anlamda geliştirilmişti. Bu teorik altyapının mekanizmalarını, en yaygın sistem dili olan C’yi nesne-merkezli özelliklerle genişleten bir dil olan C++ programcıların kullanımına sunmasına rağmen nesne-merkezli yaklaşımın yaygınlaşabilmesi için 2000’li yılları beklemek zorunda kalmamızın pek çok sebebi vardır. Ama sanırım en öenmli sebep, alışkanlıkları kırmanın zorluğu gibi .

İlk başlarda sistem programlama amacıyla geliştirilen C dili kısa sürede çok farklı uygulamaların ortak dili haline geldi. Temel olarak Algol68 gibi yapısal bir dil ile CPL gibi sistem dili üzerine bina edilen C, ilk defa 1972 yılında Bell Laboratovarları’nda Dennis Ritchie tarafından geliştirildi. Yaygın olarak kullanılan Unix versiyonlarında C dilinin bir derleyicisinin olması, C’nin yaygınlaşmasını sağladı. Sonrasında 1980’lerin başında Bjarne Stroustrup tarafından, C’ye nesne-merkezli özelliklerin katılmasıyla C++ geliştirildi ve “a better C” ya da “C with classes” gibi tabirlerle ifade edildi. 80’li yılların ikinci yarısı C++’ın hızlıca gelişmesine şahitlik yaptı. C++, pek çok derleyicisiyle yaygınlık kazanmasına rağmen, çok aşağı seviyeli bellek işlemleri yanında dinamik metotlar gibi nesne yapılarına sahip olmasının getirdiği aşırı hibrid ve karmaşık yapısından dolayı hiçbir zaman nesne-merkezli yaklaşımı ana programlama pradigması yapamadı.

Hibrid de olsa nesne-merkezli yapıların daha fazla konuşulur hale geldiği ortamda Eiffel ya da Python gibi çok yaygınlık kazanamayan farklı nesne-merkezli diller piyasaya çıktı. Ama şüphe yok ki, bu girişimlerin en başarılısı, 1995 yılında resmen piyasaya sunulan ve BT teknolojileri içinde şu ana kadar en hızlı kabule mazhar olan Java’dır. Web teknolojilerinin ortaya çıkmasına paralel ve bu yapıları destekleyerek sunulan Java, nesne-merkezli programlama yaklaşımı, BT dünyasına benimsetti; Java dili, nesne-merkezli uygulama, nesne-merkezli kurumsal mimari, tasarım deseni, bileşen ve cerçeve gibi kavramları yazılım geliştirmenin ana unsurları haline getirdi ve bu bağlamda pek çok yeni yaklaşımın da ortaya çıkmasını sağladı.

Alışkanlıkları kırmak kolay değildir. Yoğun olarak yordamsal düşünmeyle yoğrulmuş yazılım geliştirme pratiğimizin kısa sürede nesne-merkezli olması mümkün değildir. Her şeyden önce böyle bir geçişin olabilmesi için bu iki yaklaşım arasındaki farkların, artı ve eksilerinin bilinmesi ve değerlendirilmesi gereklidir. Java ve sonrasında Microsoft’un çıkardığı C# dili ve .NET çerçevesi ile geliştirilen uygulmaların ne kadarının nesne-merkezli ne kadarının hala yordamsal olarak yazıldığı araştırılması gereken bir nokta olmakla beraber bu dillerin sunduğu nesne yapılarını başarıyla kullanan BT organizasyonlarının yazılımlarını daha rahat yönettiklerine sık sık şahit olmaktayız.

Toplam görüntülenme sayısı: 1071

Nesne-merkezli mi Nesne-yönelimli mi?

Java, Yazılım Mühendisliği , , , , ,

Yazılarımı okuyanlar neden ısrarla, Türkiye’de yaygın olduğunu aksine, “nesne-yönelimli” demek yerine “nesne-merkezli” demeyi tercih ettiğimi merak ediyor olabilirler. Bu yazıda hızlıca bunu açıklamak istiyorum.

Kanımca İngilizce’deki “object-oriented” tamlamasının dilimize “nesne-yönelimli” olarak çevrilmesi, hem “orient” kelimesinin anlamının “yönelme” olarak belirlenmesi açısından hem de yapılan iş, yani “object-oriented programming” açısından problemlidir. Kısaca problem şudur: Yönelmek bir erişim gayretini ve iddiasını, yönelinen şeye kavuşma arzusunu ifade eder. Bu açıdan “object-oriented programming” yapanların nesneye kavuşmak diye bir arzuları kesinlikle olamaz, çünkü onlar zaten nesnenin içindedirler. Nesne-merkezli dillerde herşey nesnedir ve her yapı da nesne ile ilgilidir. Çünkü bu diller, gerçekliği, içerisindeki nesnelerden hareketle resmederler. Dolayısıyla doğru ifade “nesne-merkezli” ya da “nesne-odaklı” olmaktır.

Bu noktada “object-oriented” kavramının Türkçe’de “nesneye dayalı” ya da “nesne tabanlı” olarak kullanıldığına da şahit olmaktayım. Böyle bir çeviri kavram kargaşasına yol açacaktır; çünkü programlama dilleri literatüründe “object-based” kavramı vardır ve bu tamlama, ayrıntılarına burada girmek istemediğim, daha kısıtlı bir “object-oriented” yaklaşımı ifade eder. Bundan dolayı “nesneye dayalı” ya da “nesne tabanlı” tamlamaları da “object-oriented” ile kastedileni karşılamamaktadır.

Bu sebeple, bu kavramı dilimize samimi bir gayretle kazandırırken “nesne-yönelimli”yi tercih edenlere saygıda kusur etmeden, “nesne-yönelimli” olmak yerine “nesne-merkezli” ya da “nesne-odaklı” olmayı daha doğru buluyorum. Ortak bir teknoloji dili oluşturmaya ufak bir katkı olması umuduyla…

Toplam görüntülenme sayısı: 1387

Java Tuzakları – I: Aritmetik Yükseltmeler

Java, Java Dersleri , , , , , , ,

Her dilde olduğu gibi Java’da da ilk görüşte son derece saçma olduğunu düşündüğümüz pek çok şey var. Aslında bu ilk bakışta saçma görünen şeylerin bazılarının ardında yatan sebepleri araştırdığınızda, o kadar da saçma olmadığını anlarsınız. Bazen ardında çok ciddi bir sebep vardır ve düşününce hak verirsiniz. Bazen o kadar iyi bir sebep yoktur ve saçmalığın, sadece dili geliştiren takımdaki geliştiriciler arsındaki belli kopukluklardan meydana geldiğini anlarsınız. Sebebi ne olursa olsun ben Java Tuzakları başlığı altında zaman zaman karşıma çıkan Java tuzaklarından bahsetmeye çalışacağım ve sebeplerini de araştırabildiğim ölçüde paylaşacağım.

İşte ilk tuzağımız, ismi “Java’da iki byte bir byte etmez”. Nasıl mı? Aşağıdaki kod parçasına bakın:

package javaturk.trick.promotion;

public class Bytes {

public static void main(String[] args) {

byte b1 = 3;
byte b2 = 2;
// byte b3 = b1 + b3;
byte b3 = (byte) (b1 + b2);

}
}

“Java’da iki byte bir byte etmez” derken kastetiğim şey, 9. satırın derleme zamanında hata verecek olması. Sebebi ise “+” operatörünün iki argumanından birisi byte, short ve char, yani “int”den küçük bir basit tip olduğunda, sonucun “int” tipine yükseltmesi. Java’da “promotion” yani yükseltme denen bu özellikten dolayı “+” her zaman en azından int bir sonuç üretir.

Java’da bu tip yükseltmeler “Numerical Promotions” olarak adlandırılır ve iki türlüdür:
Tekli yükseltmeler (unary promotion) ve ikili yükseltmeler (binary promotion). Yapılan yükseltme aslında bir genişleten çevirmedir (widening conversion) ama aynı zamanda basit tipe çevirme de (unboxing conversion) içerebilir. Yukarıdaki kod, ikili yükseltmenin genişleten çevirme ile yapılanına örnektir. İkili yükseltme şu operatörler kullanıldığında yapılır: “+”, “-“, “*”, “/”, “%”, “<", "<=", ">“, “>=”, “==”, “!=”, bit operatörleri “&”, “^”, “|” ve bazı durumlarda “?” .

Aşağıdaki örneklere bakın:

package javaturk.trick.promotion;

public class NumericBinaryPromotion {

public static void main(String[] args) {
// Ornek 1
Byte b1 = 3;
Byte b2 = 2;
// byte b3 = b1 + b2;
byte b3 = (byte) (b1 + b2); // ya da
int b4 = b1 + b2;

// Ornek 2
double d1 = 4 * Math.PI;
float f1 = 7.29f;
// float f2 = 1.0/f1;
double d2 = 1.0/f1;

// Ornek 3
Short s1 = 12;
if(s1 >= 5)
System.out.println("s1 >= 5");

// Ornek 4
char c1 = 'A';
byte b5 = 123;
// char c2 = c1 & b5;
int c2 = c1 & b5;

// Ornek 5
byte b6 = 8;
int i1 = 17;
// int i2 = (b6==0) ? i1 : 4.0f;
float f2 = (b6==0) ? i1 : 4.0f;
}
}

Yukarıdaki örneklerden de anlaşılacağı üzere ilgili operatörlerin argumanlarından birisi double ise sonuç double, değilse birisi float ise sonuç float, değilse birisi long ise sonuç long, aksi taktirde sonuç int olarak hesaplanır.

Tekli yükseltmeler ise şu operatörle yapılır: Array oluştururken ve index ile ulaşırken “[]” içinde, tekli “+” ve “-” ile bit “~” operatörlerinde ve kaydırma için “>>”, “<<" ve ">>>” operatörlerinde argümanlar ayrı ayrı olarak. Yani kaydırma operatörlerinde mesafeyi belirten argüman long ise diğer argüman long’a yükseltilmez, sadece int’e yükseltilir.

Tekli yükseltme örnekleri ise şöyle:

package javaturk.trick.promotion;

public class NumericUnaryPromotion {

public static void main(String[] args) {

// Ornek 1
byte b1 = -5;
// byte b2 = -b1;
int i1 = -b1;
// byte b2 = +b1;
int i2 = +b1;
// byte b2 = ~b1;
int i3 = ~b1;

// Ornek 2
char c1 = 5;
int[] a = new int[c1];
a[0] = -c1;

// Ornek 3
int i4 = 128;
long l = 2;
int i5 = i4 >> l; // Burada yükseltme yok

byte b3 = 8;
// byte b4 = b3 << l; int i6 = b3 << l; } }

Tüm Java'cılara tuzaksız günler :)

Toplam görüntülenme sayısı: 1262

«< 66 67 68 69 70 >»