Neden Nesne-Merkezli Programlama? I

Giriş

Nesne-merkezli” (object-oriented) kavramını, BT dünyasında bulunan hemen herkes bir şekilde duymuştur. Zihinlerde bu kavram ile ilgili, genel olarak olumlu bir hava vardır. Yani farklı seviyelerde de olsa “nesne-merkezli” haberdarlığı, bilgisi ya da tecrübesi, kendi içinde daha ileri olma, daha rahat program yazabilme ya da daha rahat entegre edebilme vs. gibi üstünlükleri ifade eder. Javatürk gibi bir günlükte, nesne-merkezli olmanın bu kadar taraftarlığının yapıldığı halde bu kavramın neye karşılık geldiğinden çok fazla bahsedilmemesi, sahip olduğu üstün niteliklerinin değişik yazılarda üstü kapalı bir şekilde ifade edilmesine rağmen, bunların ikna edici örneklerle açıklanmaması çok da arzu ettiğim bir durum değildi tabi ki. Bir vesile ile zaman ayırıp, bu yazı serisi ile, nesne-merkezli olmanın ne anlama geldiğini, hem teorik hem de pratik örneklerle anlatmaya çalışacağım.

Nesne-merkezli Olmak Ne Demektir?

BT’nin en temel faaliyeti olan programlamaya tarih boyunca farklı yaklaşımlar geliştirilmiştir. Genel olarak 4 farklı isimle (yordamsal (emperative ya da procedural), fonksiyonel (functional), mantıksal (logical) ve nesne-merkezli (object-oriented)) ifade edilen bu programlama paradigmalarından tarihi olarak yordamsal olanı en önce ortaya çıkmış (aslında Lisp gibi mantıksal yapıdaki bir dil, 1958 yılı gibi çok erken bir dönemde geliştirmiştir ve bu açıdan ikinci yüksek seviyeli dil olarak olarak gösterilmektedir) ve çok uzun süre genel amaçlı program geliştirmenin tek yöntemi olarak kalmıştır. Bu durum, 90’lı yılların ortalarında Java’nın çıkıp nesne-merkezli programlamaya çok ciddi bir ivme kazandırmasıyla değişmeye başlamış olmakla birlikte henüz nesne-merkezli programlamanın lider yaklaşım olduğunu söylemek için çok erkendir. Fonksiyonel ve mantıksal yaklaşımları gerçekleştirmek için geliştirilen çok güçlü diller olmakla birlikte, bu diller, daha çok bu yaklaşımların güçlü olduğu alanlarda kullanılıp, genel bir yaygınlık kazanmamışlardır. Dolayısıyla bu seride, bu paradigmalardan nesne-merkezli olanını açıklarken, daha iyi anlamak amacıyla, alternatifi olan ya da daha doğru bir ifadeyle yerine geçmeye çalıştığı yordamsal paradigma ile kıyaslayacağız.

Nesne-merkezli (“Object-oriented” tamlamasını, ülkemizde yaygın olduğu gibi “nesne-yönelimli” olarak dilimize çevirmek yerine neden “nesne-merkezli” demeyi tercih ettiğimi bir başka yazımda açıklamıştım.), temelde bir programlama yaklaşımıdır, fakat kavram, nesne-merkezli veri tabanı (object-oriented database) ya da nesne-merkezli analiz (object-oriented analysis) gibi ilgili diğer bağlamlarda da kullanılmaktadır. Bir programlama yaklaşımı ya da paradigması olarak nesne-merkezli programlama, her şeyin nesne (object) üzerine kurulduğu bir programlama yaklaşımıdır. Bu yaklaşımın kurucusu sayılan Alan Kay’in sıraladığı, ileride detaylı olarak ele alacağımız, nesne-merkezli programlamanın prensiplerinden ilkinin “herşey bir nesnedir” (everything is an object) olması, bu durumu güzel bir şekilde ifade etmektedir.

Nesne-merkezli dillerin en temel iki güçlü olduğu nokta, gerçekliği ifade etme ve değişimi yönetme becerisidir. Şimdi sırasıyla bu iki noktayı ele alalım.

Gerçekliği İfade Etme Gücü

Gerçekliği ifade etme gücünden, yazılımların modelledikleri problem alanını, ne ölçüde gerçeğine uygun modelleyebildiklerini kastediyoruz. Bu ise felsefe ve bilişsel bilimlerde (cognitive science) soyutlama (abstraction) ile ifade edilen şeydir. Dolayısıyla programlamanın ilk günlerinden bugüne bu konuda ne gibi ilerlemeler olduğunu, yordamsal ve nesne-merkezli programlamanın soyutlama yapılarından kalkarak ele alabiliriz.

Yordamsal/Prosedürel Programlama Nedir?

1950’lerde, programlamanın ilk yıllarında, programlama doğrudan makina dilinde yapılıyordu ve ortaya çıkan koda da makina kodu deniyordu. Zaten yazılan programlar da yeterince küçüktü ve üzerinde çalışılan bilgisayarlar, şu ankilerle kıyaslanamayacak derece ilkeldiler. Dolayısıyla programların etkin çalışması önemliydi. Bu yüzden makina dili çok zaman yeterli olabiliyordu. Makina kodu, 0 ve 1′lerden oluşmakta olup, ilk nesil kod (first-generation code) olarak adlandırılmaktadır. Daha sonraları, makina koduna çevrilebilen, 2.nesil yapılar ortaya çıktı: Assembly dilleri. Bu diller, içinde ADD, PUSH, PULL gibi komutlar barındıran ve assembler denen çevirici programlar tarafından makina koduna çevrilebilen bir üst seviyeli dillerdi.

Sonraları, makina dilinin komutlarını daha basit bir şekilde çağırmayı sağlayacak, üçüncü nesil, ilk programlama dilleri geliştirildi. Genel kabule göre ilk yüksek seviyeli dil Fortran’dır. İsmi “FORmula TRANslating”den türetilen bu dil, 1957 yılında ticari olarak piyasaya sürüldü. Fortran’ın en temel özelliği, matematiksel problemleri kolayca çözmeye yarayacak yapıları içermesiydi. Bu yapılar, makina dili seviyesindeki pek çok komutu daha yukarı seviyede ve daha basit şekilde yerine getiren soyut komutlardı. Her ne kadar Fortran, makina diline göre daha soyut bir yapıda olsa da, öngördüğü programlama yaklaşımı, alt taraftaki makina dilinin çalışmasından çok da farklı değildi: Arka arkaya çalıştırılan ifadeler. İfadeler ise komutların farklı dizilişleriyle oluşuyordu. Bu şekilde, bir programlama anlayışı gelişti: Komut-merkezli programlama (imperative programming).

Dillerdeki ifadeler, bir programın cümleleri gibidir. Komut-merkezli programlamada ifadeler sırayla çalıştırılır ve bu sırayı programcı kodunu yazarken belirler. Yazılan kod, bir derleyici tarafından makina diline çevrilir ve üretilen kod da çalışma zamanında makina üzerinde çalıştırılır. Bu açıdan komut-merkezli programlama, en eski ve en oturmuş yaklaşımdır. Yapısı, makina diline ve yapısına çok benzediği için, genelde performansı en yüksek diller, komut-merkezli dillerdir.

1960’larda popüler olan yapısal programlama (structured programming), programı, adına birim/modül (module) denen irili ufaklı pek çok alt parçaya bölmeyi tavsiye ediyordu. Modüller, ana modülden ya da diğer modüllerlerden değer alıp onlara değer döndürebiliyorlardı. Her modül, kendi yerel değişkenlerine (local variables) ve yerel ifadelere sahiptir. Bu şekilde, ayrık işler/görevler modüllerde yazılıyor ve ana modülden tekrar tekrar çağrılabiliyordu. Böylece modüler ya da başka bir deyişle yordamsal (procedural) programlama ortaya çıktı.

Yordam, farklı dillerde subroutine, procedure, operation, function, method gibi adlarla anılsa da aslen karmaşıklığı, böl-parçala yöntemiyle yönetmeyi hedefleyen, tekrar kullanımı öne çıkaran ve bu şekilde hataya daha az yer veren yordamsal programlamanın en temel aracıdır. Bu durum aynı zamanda yordamsal programlama yaklaşımının en temel problemidir de. Çünkü, yordamsal dillerin temel soyutlaması iştir (task) ve işler yordamlarla (bundan sonra fonksiyon) ifade edilirler. Bu anlamda fonksiyonlar, yordamsal programlamanın en temel modülleridir. İhtiyaç analizinden gelen fonksiyonel ihtiyaçlar da fonksiyonel çözümleme (functional decomposition) ile atomik fonksiyonlara karşı getirilir öyle ki sistem, her adımda bir fonksiyon çalıştırarak yerine getirmesi gereken iş süreçlerini gerçekleştirir. Dolayısıyla yordamsal dille programlama yaparken, (hatta Java gibi nesne-merkezli bir dille bile programlama yaparken (!)) algımızın merkezinde bir büyük işin modülerleştirilmesi, yani adım adım işletilecek alt işlere bölünmesi ve bu alt işlerin doğru sırayla çağrılmasını yönetecek yapı vardır.

Yordamsal Yaklaşımın Problemleri: İfade Gücü ve Değişimi Yönetebilme

Yukarıda ifade edilen, yordamsal programlamanın en temel modülünün bir fonksiyon olması şu iki problemi de beraberinde getirir: İfade gücü eksikliği ve değişimi yönetebilme zaafiyeti. Bu yazıda ilk problemi ve nesne-merkezli dillerin ifade gücünü ele alacağız. Yazılımların değişimi ve bunu yönetme konusunda yordamsal ve nesne-merkezli dillerin yaklaşımı da bir sonraki yazımızın konusu olacaktır.

İfade Gücü

İfade gücüyle neyi kastettiğimizi ilk nesne-merkezli dil olan Simula’nın ortaya çıkış sürecinden örneklerle açıklayalım. Simula, adından da anlaşılacağı üzere başlangıçta simulasyon amaçlı olarak geliştirilmişti. Önce bir sistem tanımlama sonra da bir programlama dili olarak gelişen Simula aslında bir dil ailesinin ismi olup, karmaşık fiziksel sistemlerin tanımlandığı ve simule edildiği Norveç Bilgisayar Merkezi’nde, Kristen Nygaard ve Ole-Johan Dahl tarafından geliştirildi. Dilin gelişme sürecini incelediğinde, 1960’lı yıllara damgasını vuran yaklaşımın yapısal programlama (structured programming) olduğu ve bu ad altında ifade edilen yordamsal programlama tekniklerinin, Fortran ve Algol dil ailesiyle yaygın olarak uygulandığı görülür. Böyle yaygın ve güçlü olan dillerin varlığına rağmen Nygaard’ı farklı bir yaklaşıma iten şey ise onun, bir sistemdeki yapı ve davranış farklılıklarını (heterogeneity), o zaman var olan yapısal dillerde ifade etmede zorluk çekmesiydi. Daha sonraları bir veri soyutlama (data abstraction) tekniği olarak ele alınacak olan sınıf (class) kavramı ilk defa bu amaçla Simula dilinde ortaya çıktı. Aslında olan biten, tamamen algoritmik yapıda olan yordamsal dillerin gerçekte var olan karmaşık nesneleri ifade etmede aşırı indirgemeci davranması probleminden dolayı, nesneleri oldukları gibi ifade edebilme arayışından başka birşey değildi. Sonraları, yordamsal dillerde var olan integer, floating-point, char vb. gibi temel veri tiplerini bir araya getirerek karmaşık tipleri ifade etmeye imkan tanıyan soyut veri tipi (abstract data type) kavramı (Aslında hiç de soyut olmayan, gerçeklikte var olan karmaşık ve çoğu zaman somut şeyleri ifade etttiğimiz veri yapılarını kastediyoruz. Fakat bunlara “soyut” denmesinin sebebi, daha gerçek olan (!) int ve char olan basit veri tiplerinin üzerine bina edilmiş olmalarıdır.) dillere girdiyse de yordamsal dillerin gerçek dünyadaki nesneleri sadece integer gibi basit tiplerle ifade etme alışkanlığında pek de ilerleme olmadı. Yani yordamsal diller her ne kadar soyut veri tiplerini tanımlamaya imkan veren yapılara (ADA’da record type ve C’de struct gibi) sahip olsalar bile, bu yapılar nesne-merkezli dillerin nesnesi düzeyinde değildi ve ifade gücünü arttırıcı yönde olmalarına rağmen nedense bu dilleri kullananlar arasında çok da yaygınlaşamadı.

Yordamsal dil kültüründe, gerçek dünyadaki somut ya da soyut olarak var olan varlıkların, özellik ve davranışlarıyla bir bütün olarak, nesne formunda ifade edilmeyip, integer gibi basit tiplere indirgenmeleri çok yaygın olduğundan bahsettik. Yani bu dillerle yapılan projelerde bir ürün barkoduyla, bir öğrenci numarasıyla, bir banka hesabı IBAN’iyle ifade edilir. Halbuki yazılım sistemleri, bu gibi nesneleri daha bütüncül olarak ele alma ve kullanma eğilimindedirler. Örneğin yazılım sisteminin fiyat hesaplama modülünde, ilgili ürünün toplam fiyatını belirlemede sadece ürünün barkoduna değil, ürünün tipine, vergi oranına, hatta içinde bulunduğu alış-veriş bağlamına göre, yani örneğin kimin, ne zaman ve ne kadar satın aldığına göre değişen indirim miktarına da ihtiyaç olur. Bu durum ise bizi, gerçek dünyadaki ürün, müşteri, satın alma gibi kavramları, integer ya da bir başka basit veri tipleriyle ifade etmek yerine, aslına daha uygun olarak, gerçek dünyadaki bağlamında olduğu gibi, tüm özellikleriyle bir bütün olarak ifade etmeye zorlar. Bu bütünlük, nesnelerin sadece özellikleri değil davranışları için de geçerlidir. Her nesne, gerek kendisiyle ilgili gerek ise diğer farklı türde nesnelerle ilgili belli davranışlarda bulunur, diğer nesneleri etkiler, onlarla iletişimde olur. Buna nesnelerin davranışları (behavior), hizmetleri (service) ya da sorumlulukları (responsibility) denir. Nesneler birbirlerine mesaj (message) göndererek, karşılıklı hizmet alış verişinde bulunurlar: Kendisine hizmet isteği içeren bir mesaj gelen nesne de sorumluluğunu yerine getirir ve bunu gerekiyorsa bir başka mesajla hizmeti isteyen nesneye iletir. Bu şekilde nesneler mesajlaşarak iletişirler ve yazılım sistemi de zaten kocaman bir iletişim ortamından başka birşey değildir.

Yazılım sistemlerinin, gerçek dünyadaki varlıkları modelledikleri sürece, nesnelerden oluşması en tabi durumdur. Varlıkları, int gibi basit yapılara indirgemek yerine, onların özellik ve davranışlarını bir arada sarmalayan (encapsulation) nesnelerle ifade etmek, sanıldığının aksine yazılımları çok daha kolay ve anlaşılır kılacaktır. Bu iddianın en tabi delili ise, zaten zihnimizin nesne kavramı üzerinden düşünmesidir. Bu anlamda nesneler, yazılım geliştirmenin en tabi bloklarıdır, modülleridir.

Nesneler üzerinde biraz daha düşündüğümüzde, aslında hiçbir nesnenin, bir yazılım sistemi içinde, tek başına, diğerlerinden yalıtılmış bir şekilde var olmadığını farkederiz. Çoğu zaman nesneler, birbirlerinin parçası olurlar. Örneğin bir ürünün, önce bir şirketin bir malı olarak üretildiğini, sonra deposunda saklandığını, sonra bir satın almanın parçası olduğunu ve sonrasında ise bir başka kişi ya da kurumun sahipliğinde hayatına devam ettiğini düşündüğümüzde ne demek istediğimiz daha açık olur. Nesnelerin birbirleriyle olan irtibatı (association), bazen sadece birbirlerinden hizmet almakla sınırlı olur, faturalama yapan nesnenin, ürünlerin fiyatlarını, ürünlere sorarak öğrenmesi gibi. Bazen ise bir nesnenin, diğerinin parçası olması şeklinde, bir bisiklet ile onun parçaları gibi, çok daha kuvvetli türde, bütün-parça (whole-part) ilişki söz konusu olur ki bu durum, nesne-merkezli modelleme süreçlerinde “sahip olma” (has-a) ilişkisi olarak ifade edilir.

Nesneler arasındaki ilişkiler sadece bir nesnenin diğerini bilmesi ya da ona sahip olmasıyla ifade edilmez. Benzer nesneler, bir kalıtım hiyerarşisi içinde ifade edilebilirler. Yukarıdaki ürün örneğimize dönersek, bir şirketin ürettiği farklı ürünler, örneğin yiyecek ve giyecek ürünler ya da bireysel ve kurumsal müşteriler gibi nesneler arasında benzerlik şekilleri karşımıza çıkar. Bu tip ilişkiler de, nesne-merkezli düşünce süreçlerinde benzeri olma ya da miras/kalıtım (is-a) ilişkisi olarak ifade edilirler.

Yordamsal paradigmanın gerçek dünyanın nesnelerine indirgemeci yaklaşması sonucunda, bu paradigma içinde geliştirilen diller, nesneyi ve nesneler arasındaki, yukarıda bahsedilen ilişkileri ifade etmeye değil de, bir işi adım adım yapacak şekilde çözmeye ve bu çözme işlemi sırasında da ihtiyaç duyulan verileri en basit halde ifade etmeye odaklanmıştır. Yordamsal diller, nesneleri ve aralarındaki ilişkileri ancak, çok indirgemeci ve aşırı şekilde etkin (efficient) bir matematiksel notasyonla ifade etmeye çalışmış ve bu durum programlamayı daha da zorlaştırmıştır.

Object-oriented terimini ilk defa kullanan ve Smalltalk dilinin mucidi Alan Kay, nesne-merkezli dillerin en temel 6 özelliğini şöyle ifade etmişti: (Aslında Kay’ın bu maddeleri, “The Early History of Smalltalk” isimli makalesinde sıralamıştır. Kendisi bu maddelerin ilk üçünün, nesnenin ne olduğuyla ilgili çok temel prensipler olduğunu, son üçünün ise Smalltalk’ın farklı sürümleriyle daha değişik şekillerde gerçeklendiğini ifade eder. Daha geniş bilgi için buraya ve buraya bakabilirsiniz.)

  • Herşey bir nesnedir (Everything is an object.): Evet, gerçek dünyada sayılar bile çoğu zaman sadece üç-beş rakamın bir araya gelmesinden daha fazla şey ifade ederler. Örneğin sayıları her zaman bir bağlamda kullanırız ve anlam taşımaları için başka bilgilere de ihtiyacımız olur: Bir gömleğin fiyatının 49.99 TL olması, bu fiyatın içinde %18 oranında KDV olması ve şu anda %20 indirimde olması ve hatta 3 tane alana 4.cünün bedava olması gibi. İşte bu yüzden en atomik gerçekliği ifade etmek için bile birden fazla bilgi parçacığının bir araya gelmesine ihtiyacımız vardır. Bu yüzden de herşey bir nesne olmalıdır ve her nesne, içerisinde, soyutladığı ya da temsil ettiği şeyle ilgili hem özellikleri hem de davranışları ifade etmelidir. Buna sarmalama (encapsulation) denir.
  • Nesneler birbirleriyle mesajlaşarak iletişimde bulunurlar (Objects communicate by sending and receiving messages): Nesneler, bir kavramı, düşünceyi, duyguyu ya da gerçek dünyadaki fiziksel bir nesneyi, kısaca düşünebildiğimiz, özellik ve davranışlarıyla betimleyebildiğimiz herhangi bir şeyi ifade ederler. Sistemler ise birden fazla nesnenin birbirleriyle anlamlı ve amaçlı bir ilişkide olması demektir. Dolayısıyla yazılım sistemi de birbirleriyle mesajlaşan/haberleşen nesnelerden oluşur. Her nesne, sahip olduğu davranışları arayüz (interface) yoluyla diğer nesnelerin hizmetine sunar. Mesajlaşma yoluyla da nesneler birbirlerinden hizmet alırlar ve yazılım sistemi süreçlerini işletir.
  • Her nesnenin bir belleği vardır (Objects have their own memory): Her nesne, iletişimde olduğu diğer nesneler hakkında bilgiye sahiptir. Bu bilgi bazen, bir bisikletin, tekerleğine sahip olmasındaki gibi (has-a) sıkı bir ilişkidir ki, bu durumda tekerlek, bisiklerin bir özelliğidir, bazen de bir alış-veriş kasasının, bir ürünü, ona fiyatını sorabilecek kadar tanıması gibi çok daha gevşek türden bir ilişkidir.
  • Her nesnenin bir sınıfı vardır (Every object is an instance of a class): Nesneler, gerçek dünyadaki farklı kategorilerin, sınıfların  ya da tiplerin tikel örnekleridir (instance). Bu anlamda yazılım sisteminde de her nesnenin bir kategorisi, sınıfı ya da tipi vardır. Aslında nesnelerin genelde birden fazla tipleri vardır (ama bunun mekanizmalarına girmek bu yazı için uygun değildir). Bu, bir insanın hem öğretmen, hem baba, hem futbol seyircisi, hem Ayvalık’lı olması, hem yüzmeyi bilmesi vs. gibidir. Nesne-merkezli diller gerçekliğe uygun bir şekilde çok tipli ya da şekilli (polymorphic) nesneleri betimlemeye imkan tanırlar. Ve bu çok tipli nesneler farklı bağlamlarda farklı tiplerini öne çıkarırlar.
  • Sınıf, nesnelerinin ortak davranışlarını ifade eder (The class holds the shared behavior for its instances): Bir sınıfın bütün nesneleri, o sınıfta ifade edilen davranışlara sahiptirler. Nesneler arasında benzerlik ilişkileriyle genel-özel ya da ebeveyn-çocuk olarak ifade edilen hiyerarşiler oluşturulabilir. Bu durum miras/kalıtım (is-a ya da is-like-a) olarak ifade edildiğini yukarıda belirtmiştik. Daha özel nesneler yani hiyerarşide daha aşağıda olan nesneler, daha genel olan en tepedeki nesnenin cinsinden ya da sınıfındandırlar ve o sınıfta ifade edilen davranışlara sahiptirler. Bu durum, aynı sınıftan olan nesneler aynı davranışları gösterirler şeklinde de ifade edilir. Fakat daha özel nesneler, ebeveynlerinden devraldıkları davranışların keyfiyeti konusunda inisiyatif alabilirler. Örneğin bir ürünün, temel bir gıda maddesi olması, gömlek olan bir başka ürüne göre, davranışlarını etkiler; yani fiyatının nasıl hesaplanacağını, depoda nasıl saklanacağını kendi durumuna has olarak bilir. Bu anlamda aynı tipten olan nesneler aynı davranışları farklı keyfiyette ya da şekilde yerine getirir. Bu durum ise nesne-merkezli dillerde fonksiyonların ya da daha doğru ifadeyle metotların çok şekilli (polymorphic) olması olarak adlandırılır.
  • Nesne-merkezli bir program, ilk nesneye gönderilen mesajla başlar ve sonrası da bu nesnenin mesajıdır (To eval a program list, control is passed to the first object and the remainder is treated as its message): Nesne-merkezli yazılım, birbirleriyle haberleşen nesnelerden ibaret ise, yazılımın çalışmaya başlaması, ilk nesneye bir mesaj göndermekle olur. Sonrasında ise ilk nesne diğer nesnelerle haberleşerek, bir haberleşen nesne ağı oluşturulur ve yazılım çalışma-zamanına girmiş olur.

Gerçek dünyadaki iş süreçlerini bir bitler ve bytelar düzlemine taşıyan yazılımların başarısı, bu taşıma sırasında gerçekliği ne kadar iyi tasvir ettiğiyle alakalıdır. Bu anlamda nesne-merkezli dillerin ifade gücü, gerçekliği olduğu gibi resmedebilme becerisinden kaynaklanmaktadır. Benim şahsi tecrübem de, yazılımların, resmetmeye çalıştıkları, gerçek dünyadaki nesneleri ve aralarındaki ilişkileri, aslına uygun ifade edebildiği ölçüde sağlıklı olduğudur. (Timothy Budd’ın “nesne-merkezli programlamada, hesaplama (ya da yazılım) simulasyondur”  (“Thus in object-oriented programming we have the view that computation is simulation) şeklinde çevirebileceğimiz sözüyle ifade edilen şey de zaten yazılımların tek yaptığı şeyin gerçekliği taklit etmek olduğudur. Budd, “Introduction to Object-Oriented Programming” isimli kitabında söylediği bu cümleyi, Kay’in 1977 yılında Scientific American dergisindeki yazısına dayandırır. Bu yazıda Kay, “The social impact of simulation – the central property of computing – must also be considered.” demektedir. ) Çünkü bu şekilde modellenen yazılımlar, daha basit olurlar, daha rahat anlaşılırlar, daha rahat anlatılırlar, daha rahat kodlanırlar, daha rahat test edilirler, daha rahat dokümante edilirler, vs. Yordamsal diller ise iş süreçlerini değil, bilgisayarların çalışma süreçlerini modelleyen yapıdadırlar. Bu yüzden yazılımlar hayatımıza girdiği ölçüde, nesne-merkezli dillerin kullanılması kaçınılmaz olacaktır.

Bu yazı toplam 2767 defa görüntülenmiştir.