Bu yazının amacı, PROLOG diline giriş yapmak ve basit bazı yapay zeka problemlerinin PROLOG dilinde nasıl kodlanarak çözüldüğünü göstermektir.

Kurulum ve çalıştırma:

Bu yazı kapsamında SWI-PROLOG programı kullanılacaktır. Programı, www.swi-prolog.com adresinden temin etmek mümkündür.

Yazı kapsamında MAC OSX üzerinde örnekler çalıştırılarak gösterilecektir ancak kurulum ve sonrasında başarılı bir çalıştırma yapılabiliyorsa hangi işletim sisteminde olduğunuzun bir önemi yoktur, bütün sistemlerde aynı PROLOG komutları çalışır.

Siteden indirilip kurulum yapıldıktan sonra,

$ /opt/local/bin/swipl 

Dizini altında bulunan swipl komutu çalıştırılarak, PROLOG komut satırı açılabilir.

Program çalıştırıldığında, aşağıdakine benzer bir komut satırı ile komut girilmesini bekleyecektir:

?- _

Yardım

İlk ve en önemli komutumuz olan yardım komutu ile başlayabiliriz.

?- help(help).

Bu komut, X11 ekranında, yardım dokümanını görüntüleyecektir. Basitçe herhangi bir komut hakkında bilgi alınmak istendiğinde bu komutu help fonksiyonuna parametre olarak vermek yeterlidir. Yukarıdaki kullanımda help komutunun kendisi için yardım alınmıştır.

Çıkış

Prolog komut satırından çıkmak için

?- halt.

Yazılması yeterlidir. Bu komut programı sonlandıracaktır.

Basit Kaziyeler

Aşağıdaki komutları PROLOG üzerinde çalıştıralım ve ardından burada yapılan işlemleri yorumlayalım.

Sistemimizde kayıtlı olan bir dosyayı program tarafından açıp çalıştırılır bir şekilde yüklemek için dosya ismi köşeli parantezler içerisinde verilmelidir:

?- [‘ilkdosya.pl'].

Yukarıda, bilgisayarımızda bulunan “ilkdosya.pl” isimli dosyayı sisteme tanıtarak yükledik. Bu dosyada bulunan tanımlar da otomatik olarak yüklenmiş ve sorgulanmaya / çalışmaya hazır hale getirilmiş olacaktır. Ayrıca bu dosyada bulunan genel hatalar, yükleme sırasında ekrana basılır.

PROLOG ile Faktöriyel Kodu

PROLOG dili, yapısal olarak özyineli (recursive) bir yapıdadır ve döngülerin yerine özyineli fonksiyon (recursive function) kullanılması gerekir. Bu kullanımı göreceğimiz en basit uygulamalardan birisi olan faktöriyel kodunu yazıp kodlamaya çalışalım.

Herhangi bir editör açılarak (ben tercihen vi kullanıyorum, siz de istediğiniz bir editör ile dosyayı açıp içeriğini ) aşağıdaki şekilde yazabilirsiniz:

factorial(0,1).      

factorial(A,B) :- 

             A > 0,

             C is A-1,

            factorial(C,D),

            B is A*D. 

Ardından aşağıdaki şekilde dosyamızı sisteme yükleyelim:

?- ['ilkdosya.pl'].

% ilkdosya.pl compiled 0.00 sec, 732 bytes

true.

Komut satırında dosyamızın yüklendiği ve yükleme süresi ve dosya boyutu gösterilmektedir. Son satırda yer alan true bilgisine kadar bir hata bulunmamış olması, dosyamızda bir hata olmadığını gösterir. Şimdi artık ilk fonksiyonumuzu kullanmaya başlayabiliriz.

?- factorial(5,X).

X = 120 ;

false.

Komut satırında, factorial(5,X) komutu verilerek, 5! Değerinin X değişkenine döndürülmesi istenmiştir. Burada öğrenilen birkaç önemli noktayı belirtelim. Birincisi X ile gösterilen değer bir değişkendir ve PROLOG dünyasında buna unbounded variable (bağlanmamış değişken) ismi verilir. Basitçe Prolog kodlarındaki bütün büyük harf ile başlayan ifadeler birer değişkendir ve ayrıca bir değişken tanımı yapılmaz. İkinci bir nokta, Prolog dilinde kod yazılırken girilen her satır bir emirdir ( declaration) ve yapısal olarak Prolog dili, haber mantığını (predicate calculus) barındırır. Buna göre yüklü olan dosyada bulunan komutlar yukarıdan aşağıya doğru çalıştırılırken üstte bulunan satır, alttakine gore öncelikli olur ve aynı zamanda birden fazla satırda emirin tanımlanması durumunda, sırasıyla bu emirler işlenir.

Örneğin yukarıdaki kodda, ilk satırda bulunan factorial (0,1). İfadesi, 0! = 1 anlamındadır ve bir şekilde birisi bize sıfır faktöriyeli sorarsa, ikinci değer olarak 1 sonucunu döndürmeyi gerektirir.

İkinci satırdan sonra başlayan tanımda ise, sırasıyla A>0 kontrolü yapılmış, ardından C değişkenine değer olarak A-1 değeri konmuş ve yeni bulunan C değerinin faktöriyeli hesaplanarak, B sonucuna hesaplanan bu C faktöriyel değeri ile A’nın çarpımı eklenmiştir.

Yukarıdaki şekilde kodumuzu ilkdosya.pl  dosyasına yazıp kaydettikten sonra prolog komut satırında dosyamızı yükleyip çalıştırabiliriz:

Yukarıda görüldüğü üzere faktöriyel kodumuz çalışmış ve sonucu doğru şekilde bulmuştur.

Kodun çalışmasını takip etmek için trace komutu kullanılabilir. Basitçe komut satırında:

trace.

Yazıldıktan sonra çalışmaya başlar ve bu çalışmadan sonra çağrılan fonksiyonların detayları ekrana basılır:

Görüldüğü üzere factorial fonksiyonumuzun her adımı ekrana basılmıştır.

Hanoi Kuleleri (Towers of Hanoi)

İkinci bir uygulama olarak çok klasik bilgisayar bilimleri problemlerinden olan Hanoi Kulelerini ( tower of hanoi ) kodlamaya çalışalım.

Oyunun kuralı gayet basit. Başlangıçta bir çubukta dizili olan bütün diskler her adımda tek bir disk hareket ettirerek diğer iki çubuktan birisine taşınacaktır. Bu taşıma işlemleri sırasında büyük bir disk, küçük olan bir diskin üzerine gelmeyecektir.

Ayrıca oyunun internetten oynan bir denemesi için daha önce hazırladığım aşağıdaki ödev sayfasına bakabilirsiniz:

http://www.sadievrenseker.com/c/odev5.html

Problemin çözümünde kullanacağımız kod aşağıdaki şekildedir:

SADIs-MacBook-Air:prolog sadievrenseker$ vi hanoi.pl

oyna(1,X,Y,_) :-

    write(X),

    write(‘ en üstteki diskini ‘),

    write(Y),

    write(‘ oynat ‘),

    nl.

oyna(N,X,Y,Z) :-

    N>1,

    M is N-1,

    oyna(M,X,Z,Y),

    oyna(1,X,Y,_),

    oyna(M,Z,Y,X).

Kod örneği yukarıda verilmiştir. Kodumuzun çalışmasını görüp ardından nasıl çalıştığını açıklamaya geçebiliriz.

?- oyna(4,a,b,c).

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

a en üstteki diskini c oynat

b en üstteki diskini a oynat

b en üstteki diskini c oynat

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

c en üstteki diskini a oynat

b en üstteki diskini a oynat

c en üstteki diskini b oynat

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

true .

?-

Yukarıdaki çalışmadan da görüldüğü üzere ilk baştaki 4 diskin dizili olduğu a çubuğundan bütün diskler sırasıyla b çubuğuna taşınmıştır.

Kodumuz, doğru sıra ile oynama yaklaşımı ile kodlanmıştır. Hanoi kulelerinin farklı çözümleri bulunur. Örneğin geri izleme algoritması (backtracking) kullanarak kaba kuvvetle (brute force) bütün ihtimallerin denendiği ve başarısızlık olması halinde en son iyi duruma geri dönen yaklaşımları kodlamak da mümkündür.

Bizim kodlamamızda ise her seferinde doğru çubuktan doğru diskin oynatılması esası kullanılmıştı. Bu yüzden hiç geri oynama veya yapılan hamleden vaz geçme olmamıştır.

Bu oynama esasını daha iyi anlatabilmek için daha ufak bir örnek üzerinden çalışmayı gösterelim :

?- oyna(2,a,b,c).

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

true

Görüldüğü üzere iki disklik bir dizilimde, c çubuğu geçici olarak kullanılmakta, esas büyük diskin b çubuğuna oynanması sırasında, küçük diskleri depolamak için kullanılmaktadır.

Bu durum disk sayısı artsa da değişmez. En büyük diskin a çubuğundan b çubuğuna oynanması sırasında,  diğer bütün küçük diskleri depolamak için c çubuğunu kullanırız. Buradan anlaşılacağı üzere ikinci büyük diskin c çubuğuna oynaması gerekir. Bunun için de b çubuğunu geçici depolama için kullanırız. Bu yaklaşım en büyük diskten en küçüğüne kadar aynı mantıkla işleyerek devam eder.

8 Vezir Problemi (8 Queens Problem)

Yeni bir problem olarak klasik sorulardan birisi olan 8 vezir problemini ( eight queens problem) ele alalım. Problem basitçe bir satranç tahtasına 8 veziri, birbirini yemeden nasıl yerleştireceğimizdir.

Problemin çözümü olan PROLOG kodu aşağıda verilmiştir.

perm([X|Y],Z) :- perm(Y,W), birinial(X,Z,W).

perm([],[]).

birinial(X,[X|R],R).

birinial(X,[F|R],[F|S]) :- birinial(X,R,S).

cozum(P) :-

     perm([1,2,3,4,5,6,7,8],P),

     birlestir([1,2,3,4,5,6,7,8],P,S,D),

     hepsifarkli(S),

     hepsifarkli(D).

birlestir([X1|X],[Y1|Y],[S1|S],[D1|D]) :-

     S1 is X1 +Y1,

     D1 is X1 – Y1,

     birlestir(X,Y,S,D).

birlestir([],[],[],[]).

hepsifarkli([X|Y]) :-  \+member(X,Y), hepsifarkli(Y).

hepsifarkli([X]).

Kodun çalışan örneği aşağıdaki şekildedir:

?- cozum(P).

P = [5, 2, 6, 1, 7, 4, 8, 3] ;

P = [6, 3, 5, 7, 1, 4, 2, 8] ;

P = [6, 4, 7, 1, 3, 5, 2, 8] ;

P = [3, 6, 2, 7, 5, 1, 8, 4] ;

P = [6, 3, 1, 7, 5, 8, 2, 4] ;

P = [6, 2, 7, 1, 3, 5, 8, 4] ;

P = [6, 4, 7, 1, 8, 2, 5, 3] ;

P = [3, 6, 2, 7, 1, 4, 8, 5] ;

P = [6, 3, 7, 2, 4, 8, 1, 5] ;

…

Yukarıdaki örneklerde görüldüğü üzere her kolon için, o kolondaki kaçıncı satıra vezir yerleştirilebileceği ve bu yerleştirme işlemine göre bütün kuralları sağlayan bir dizilimin nasıl elde edileceği listelenmiştir. Problemin birden fazla çözümü olduğu için her satır, çözümlerden birisini göstermektedir. Örneğin ilk çözüm satırını ele alırsak, aşağıdaki gibi bir satranç tahtası elde ederiz.

P = [5, 2, 6, 1, 7, 4, 8, 3] ;

Kodda, kabaca bütün ihtimalleri deneyen bir permütasyon algoritması geliştirilmiştir. Ardından koşulların sağlanıp sağlanmadığı kontrol edilmiş ve buna göre koşulları sağlayan ihtimaller sonuç olarak döndürülmüştür.

Algoritma, bir arama algoritması (search algorithm) şeklinde probleme yaklaştığı için, problemin çözümü sırasındaki bütün ihtimaller sadece bir kere denenecek ve denenen bir ihtimal tekrar etmeyecektir. Bu deneme sırası, permütasyon fonksiyonu ile sağlanır.

113 views

Bu yazının amacı, bilgisayar programlama dillerinde kullanılan bir yaklaşım olan geri çağırım (call back) kavramını açıklamaktır.

Bir programlama dilinin, yapısal programlama dili (structured programming language) olabilmesi için aşağıdaki üç özelliğe haiz olması gerekir:

• Kod bloğunun koşula bağlı olabilmesi : Klasik programlama dillerindeki if/else yapısı
• Kod bloğunun tekrar ettirilebilir olması : Klasik programlama dillerindeki döngü (loop) yapısı
• Kod bloğunun parametrize edilebilir olması: Klasik programlama dillerindeki fonksiyon (function) yapısı

Yukarıdaki bu üç özelliği günümüz programlama dillerinin hemen hepsi bünyelerinde barındırmaktadır ve günümüzdeki çoğu dil, yapısal programlama dili olma özelliğini taşır.

Geri çağırım ismi verilen özellik ise, yukarıdaki özelliklerden üçüncüsünün parametre olarak bir kod bloğunu alabilmesidir. Diğer bir deyişle, çalıştırılacak olan kod bloğunun, parametre olarak basit sayılar veya değişkenler yerine, farklı bir kod bloğunu alması ve bu kod bloğunu çalıştırması, hatta diğer iki özelliği de kullanarak, alınan parametredeki kod bloklarını tekrar etmesi veya koşullu olarak sçmesi anlamına gelir

Geri çağırım özelliği (call back), bir programlama dilinde, aşağıdakine benzer bir yapı kazandırır:

Yukarıdaki temsili resimde, klasik bir geri çağırımda, bir ana fonksiyonun (örneğin C gibi dillerdeki main fonksiyonu olabilir), herhangi bir kütüphanede bulunan fonksiyonu çağırması ve ardından bu kütüphanenin de ana programdaki bir fonksiyonu geri çağırması ifade edilmiştir.

Bu gösterimden anlaşıldığı üzere kütüphane fonksiyonu, basitçe kendisine gelen çağırımı, ana programdan aldığı bir parametreye geri yönlendirmektedir. Bu kullanım ise C gibi dillerde ancak fonksiyon göstericisi (function pointer) yapısı ile mümkündür. Yani gelen bir çağrının, ana programdaki hangi fonksiyona yönlendirileceği (geri çağrılacağı , callback), gelen kütüphane fonksiyonuna verilmiş bir parametre olan ikinci bir fonksiyon ile yapılabilir ki bu parametrede ancak ikinci bir fonksiyon olabilir.

Bu durumu örnek bir kod ile anlatmaya çalışalım:

#include <stdio.h>
int func(int);
void PassPtr(int (*pt2Func)(int))
{
   int sonuc = (*pt2Func)(12);
   printf("%d",sonuc);
}

main(){
      int (*fp)(int);
      fp = func;
      PassPtr(fp);

}
int
func(int arg){
     return ++arg;
}

Yukarıdaki kodda bulunan main fonksiyonu, öncelikle fp isminde bir fonksiyon göstericisi tanımlamış ve bu fonksiyon göstericisini, PassPtr ismi verilen fonkisyona parametre olarak geçirmiştir. Yukarıdaki yapıda, PassPtr isimli fonkisyon, daha alt seviyede olan bir kütüphane fonksiyonu ve func ismi verilen ve main fonkisyonunda fp isimli gösterici ile ifade edilen fonksiyon ise geri çağırım yapılan fonksiyon olarak düşünülebilir.

Bu durumda, bizim tasarım yapımız aşağıdaki şekilde görülebilir

Yukarıdaki yaklaşımın faydası, bize alt seviye fonksiyonunun hiç bilgisi olmadan üst seviyedeki herhangi bir fonksiyona geri dönüş imkanı vermesidir. Bu anlamada, programda soyutlama (abstraction) yakalanmasında veya geçirilen parametreler sayesinde bilgi gizlenmesi (inforation hiding) özelliği kazandırmaktadır.

Özet olarak geri çağırım özelliği, bir programlama yaklaşımında kullanılan tasarım yöntemlerinden birisidir ve nesne yönelimli olmayan programlama dillerinde, yukarıda bahsedilen durumlarda sıklıkla kullanılan bir çözümdür. Nesne yönelimli programlama dillerinin gelişimi ile birlikte, tasarım kalıpları (design patterns) önem kazanmış ve bu kalıplardan gözlemci kalıbı (observer patter) yukarıda açıklanan özelliklerin tamamını bir nesne yönelimli programlama dilinde çözmeye yöenlik olarak programcıların hizmetine sunulmuştur.

174 views

Özellikle bilgisayar programlama dillerinde kullanılan bir terimdir. Buna göre dillerde bulunan özelliklerin birbirine dik olması, yani birbirinden bağımsız olması kast edilir. Kelime olarak, yöneylerin (vectors) dikliğinden esinlenilmiştir. Vektörlerin birbirine dik olması, aralarında ilişki bulunmaması (birbirine iz düşümünün sıfır olması) anlamına gelmektedir. Şayet bir dilde bulunan özellikler arasında da ilişki bulunmuyorsa, dilin özelliklerinin genişlemiş olduğu düşünülebilir.

Örneğin değişken tipleri olarak tamsayı (integer) ve küsurlu sayının (float) bulunduğu bir dil ve işlem(operator) olarak dizi (array) ve işaretçi (pointer) bulunduğu bir dili ele alalım. Bu dildeki 2 değişken tipi ve iki işlem şekli, şayet kaime arz ediyorsa, bu durumda bir işaretçi, tamsayı veya küsurlu sayıyı gösterebilmektedir. Benzer şekilde dizinin elemanları işaretçi olabilmekte ve işaretçi de diziye işaret edebilmektedir.

Şayet dilde, kaime bulunmasaydı, örneğin dizi işlemi, sadece küsurlu sayılar üzerinde çalışıyor olsaydı, bu durumda dildeki esneklik büyük ölçüde kaybedilmiş olacak ve örneğin tam sayı dizisi bulunmayacağı gibi, tam sayı dizisine işaret eden bir işaretçi veya her elemanı işaretçi olan bir tamsayı dizisi de kullanılamayacaktı.

C dilinde toplama işlemi (+) bulunmakta ve lisan-ı kaime gereği mümkün olduğunca değişken yapısından bağımsız tutulmaktadır.

Örneğin,

a+b şeklindeki bir işlemde, C dili, a ve b değişken değerlerini alıp hafızaya yükledikten sonra toplama işlemini yine hafızada tutmaktadır.

Yukarıdaki bu örnekte, a ve b değerleri, herhangi bir değişken tipinde olabilir. Örneğin tam sayı (int) veya karakter (char) yapısında olmasının bir mahsuru yoktur.

Ayrıca yukarıdaki a ve b değerleri birer işaretçi (pointer) da olabilir.

Örneğin;

int *a ;
int x[10];
a = x;
int b = 4;
a = a + b;

şeklindeki kodun anlamı, a işaretçisinin gösterdiği mevcut yerin 4 sonraki adresini göstermesidir. Buna göre, x dizisinin 4. elemanına işaret etmektedir. Yukarıdaki bu özellik, C dilinde bulunan ve işaretçi ile dizi ve değişken tipleri arasında bulunan diklik özelliğine istinat edilebilir.

Bir dilde diklik özelliğinin fazla olması, dildeki kodlamayı kolaylaştırır ve dilin öğrenilmesini basit hale getirir. Örneğin işaretçi kullanmayı öğrenen birisi yukarıdaki bu işlemleri ilave bir kural öğrenmeksizin kodlayabilir. Şayet diklik özelliği az olsaydı, bu durumda dili öğrenen veya kodlayan kişilerin istisna kurallarını da öğrenmesi gerekecekti. Örneğin ingilizce öğrenen birisi, fiillerin sonuna –ed eki getirerek geçmiş zaman yapılacağını öğrenir, ancak bunun istisnası olan kelimeleri de öğrenmek zorundadır. Şayet istisnası hiç olmasaydı, dili öğrenmek ve kullanmak çok daha kolay olacaktı.

Bir dildeki diklik özelliğinin çok fazla olması da sakıncalıdır. Aşırı derecede diklik içerilmesi halinde, dili çalıştıracak bir derleyicinin (compiler) geliştirilmesi imkansızlaştığı gibi kodu kullanan kişilerinde hata yapma ihtimali artar.

Örneğin C dilinde iki tip veri birliktelik ilişkisi bulunmaktadır (data associativity). Bunlar diziler (array) ve kayıtlardır (records, C dilinde özel olarak yapı (struct) ismi ile geçer). C dilinde bulunan fonksiyonlar, iki tipte de parametre alırken, sadece kayıt tipinde veri döndürebilmektedir. Dizi tipinde döndürmesi mümkün değildir. Bu durum dilin diklik özelliğine uymadığı gibi, dilde bulunan bu özelliklere de diklik eklenmesi halinde, hafıza yönetimi (Dizi boyutunun kestirilmesi) ve hafızanın ihalili gibi pek çok problemi, kodu yazan kişinin kontrol etmesi gerekecekti. Çözüm olarak, C dilinin tasarımı sırasında, bu özelliklere diklik getirilmemiştir.

211 views

Bilgisayar bilimlerinde, bir programın incelenmesi sırasında, herhangi bir kaziyenin (predicate, haber, önerme), çeşitli işlemler uygulanmasına karşılık yeknesan olması halidir.

Diğer bir deyişle, program çalışır ve çeşitli işlemlerden geçer, ancak bazı şeyler değişmeden kalıyor ve ne kadar işlem yapılırsa yapılsın değişmiyorsa buna yeknesan (değişmez, invariant) ismi verilir.

En basit örneği, bir değişkenin (variable) içine değer atanması ama hiç değiştirilememesidir.

int a = 10;
// işlemler
printf("%d",a);

Yukarıdkai kodda, a değerini ilgilendiren işlemler yapılmıyorsa, a için yeknesan olmuş denilebilir. Farklı bir örnek de döngülerde görülür:

for(int i = 0;i<10;i++){
   printf("%d",i);
}

Yukarıdaki döngüde, i<10 şartında bulunan 10′dan küçük olma şartı yeknesan olmuştur. Yani döngünün dönmesi sırasında değişmeden kalmaktadır. Hemen bu noktada önemli bir farkı belirtmek gerekir. Yeknesean kavramı, sabit kavramı ile (constant) karıştırılabilmektedir. Örneğin yukarıdaki döngüde bulunan 10 sayısı bir sabittir ve yeknesan değildir. 10′dan küçük olma durumu ise değişmeden kalan bir yeknesan olarak düşünülmelidir.
Yukarıdaki tip yeknesan örneklerine, özel olarak daire yeknesanı (loop invariant, döngü değişmezi) ismi de verilebilir.

Bu yaklaşım, ayrıca program analizi veya problem analizi sırasında da kullanılabilir. Örneğin MU Probleminin çözümünde, yeknesan bir değer yakalamaya çalışmak gerekir. Benzer şekilde Hoare Mantığı (Hoare Logic), programların belirli bölümlerinde, ön ve son koşullar belirleyerek bunların yeknesan olmasını sağlamaktadır.

Bu yöntem, bilgisayar bilimleri dışında da kullanılır. Örneğin, kanun yapım sürecinde, bütün kanunlarda değişmeyen kötü hasletler vardır. Bu yüzden, hırsızlık veya cinayet gibi suçlar, kanunlar değişmesine karşılık, bütün kanunlarda yerini almaktadır. Bu anlamda, değişen kanun sistemleri için, hırsızlık, yeknesan bir suçtur denilebilir.

243 views

Bilgisayar bilimlerinde, özellikle özyineli (recursive) problemlerde, problemin bir kısmının tekrar edilmesi durumudur. Örneğin, klasik bir problem olan fibonacci sayıları örneğinde, örtüşen altproblem bulunmaktadır.

Fibonacci serisinin 4. terimini hesaplamak isteyelim ve bunun için aşağıdaki fonksiyonu yazmış olalım:

Matematiksel olarak : fib(0) = 1, fib(1) = 1 ve fib(n) = fib(n-1)+fib(n-2)

Programlama dillerinde:

fib(int n){
   if(n==0||n==1)
      return 1;
   return fib(n-1)+fib(n-2);
}

Yukarıdaki bu fonksiyonun çalışması sırasında çağırdığı alt fonksiyonları bir ağaç şeklinde çizecek olursak:

Yukarıdaki ağaçta, görüldüğü üzere, bazı terimler birden fazla kere hesaplanmaktadır. Örneğin fib(2) fonksiyonu, hem fib(4) hesaplanırken, hem de fib(3) hesaplanırken hesaplanmaktadır. Bu anlamda, problemin bir alt grubunun (subproblem) örtüştüğünden (overlap) bahsedebiliriz. Genelde bu tip örtüşmelerde, hız kazandırmak ve problemin sadece bir kere çözülmesini saplamak için dinamik programlama (dynamic programming) yöntemi kullanılır.

192 views

Yazan : Şadi Evren ŞEKER

İyileştirme problemleri açısından klasik bir örnektir (optimisation problems). Problem basitçe bir kutunun içerisine en az boş alan bırakarak, eşyaların en iyi şekilde nasıl yerleştireceği olarak düşünülebilir.

Aslında problemi boyutlara göre incelersek aşağıdaki şekilde bir liste yapılabilir:

Tek boyutlu kutulama (1D bin packing) :Bu problemde amaç bir çizgi veya hat gibi görülebilecek yapının içerisine farklı boyutlardaki çizgileri yerleştirmek olarak düşünülebilir.

Örneğin zaman çizelgelemesinde, bir kişinin yapacağı işleri, zaman çizgisinin üzerine yerleştirmesi (ve her işin farklı miktarda zaman gerektirdiğini ve kişinin çalışma saatlerinin sınırlı olduğunu düşünürsek en fazla işi en az zamanda (örneğin 8 saatlik mesailer içinde) yapması ) bir problemdir. Buradaki hem kişinin yapacağı işler hem de bu işlerin yerleştirileceği zaman çizgisi tek boyutludur.

Daha basit olması açısından örneğin 100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek istiyoruz, en verimli bölme işleminde kaç adet 7 ve kaç adet 9 uzunluğunda ipimiz olur gibi soruları düşünebiliriz. Bu tip sorular tek boyutlu kutulama problemleridir.

İki boyutlu kutulama problemleri (2D bin packing optimization): Bu grupta bir tablodan ve iki boyuttan bahsedilebilir. Örneğin kot pantolon üreten bir tekstil firmasında farklı boyutlardaki Pantolon kalıplarının en az fire ile 5x5m büyüklüğündeki bir kare kumaştan kesilmesi isteniyor olsun. Bu problem iki boyutlu (x ve y boyutları) bir kutulama problemidir. Benzer bir problem, bir gazetedeki seri ilanların, en az fire ile sayfaya yerleştirilmesi olarak da düşünülebilir.

3 boyutlu kutulama (3D bin packing) problemin en zor şekli olarak tanımlanır ve 3 boyutlu bir kutunun içerisine konulan her şeklin farklı x,y ve z boyutlarında şekiller olması olarak düşünülebilir. Problemin genel tanımını yaptığımız için belirteyim, örneğin ev taşıma sırasında çıkan eşyaların kutulanması olarak düşünebilirsiniz. Bu durumu daha da karmaşık yapmaktadır çünkü kutular farklı boyut ve şekillerdedir (örneğin silindir bir varil veya küp veya dikdörtgenler prizması gibi kutuların içerisine yerleştirme yapılmakta) ve kutulanan şekillerde farklıdır ve hatta girintilidir (concave , non-convex) (örneğin avize, koltuk, sandalye gibi birbirinin içine girebilen nesneleri düşününüz). 2 ve 3 boyutlu paketleme, paketlenen nesnelerin girintili olup olmamasına göre ikiye ayrılmaktadır. Dış bükey nesnelerin paketlenmesi nispeten daha basit bir problemdir. Ancak nesnelerin iç bükey olması halinde problem biraz daha karmaşıklaşır.

Hatta literatürdeki kısıtlı aramalarım sonucunda ulaşabildiğim kadarıyla tam olarak iç bükey nesnelerin paketlenebildiği bir sonuç ne yazık ki bulamadım. Örneğin iki vidanın en verimlim paketlenmesi sırasında vidaların girinti çıkıntılarının üstüste gelmesi gerektiğini tecrübi olarak biliyoruz. N adet vida için bu durum birbirini tekrar eden bir hal alır. Gerçekten farklı boylarda ve adım sıklığında ve çaplarda vidalar verilse bu durumda en verimli paketlemeyi yapabilen bir algoritma henüz görmedim.

Paketlenen nesnelere göre problemin sınıflandırılması:

Paketlenen nesne çeşitlerinin sabit olması ve ön tanımlı olması halinde problem homojen olarak tanımlanır. Örneğin tek boyutlu kutulama probleminin tanımı sırasında verilen ve “100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek” şeklinde geçen örnek bu tip homojen (homogenous) bir yapıdadır. Buna karşılık heterojen bir problemde, paketlenecek nesnelerin tipleri ya tamamen birbirlerinden farklıdır ya da aynı tipte çok az tekrar vardır. Yine tek boyutlu problem örneğinde verilen zaman çizgisi üzerinde farklı uzunluklardaki randevuların yerleştirilmesi bu tiptendir.

Bu anlamda aşağıdaki problemler, kutulama probleminin birer özel hali olarak düşünülebilir:

• kamyon yükleme problemi (truck loading),

• konteyner yükleme problemi (Container loading problem, CLP)

• şerit paketleme problemi (Strip Packing problem, SPP)

Yukarıda, problemin tanımını yaptıktan sonra çözümlere bir göz atalım:

Homojen tek boyutlu problem çözümü

Şayet problem tek boyutlu ise ve homojen nesnelerin paketlenmesi olarak problemin çözülmesi isteniyorsa problem oldukça basit demektir ve basit matematiksel hesaplamalar ile problemi çözebiliriz.

Örneğin tek nesne ve tek paket varsa işlem basitçe paketin nesneye bölümü olarak bulunur (zaten burada zor Bir şey de yok):

Örneğin 100m uzunluğundaki bir ipten kaç tane 5m uzunluğunda ip kesilebilir:

100 / 5 = 20

biraz daha zorlaştırıp ip sayısını 2 çeşide veya 3 çeşide çıkarırsak problem np-tam (np-complete) bir hal alır. Örneğin aşağıdaki kodu inceleyelim:

Kodda görüldüğü üzere bütün ihtimaller denenmektedir. Basitçe herhangi bir k değeri için, k-a ve k-b değerlerini denemekte ve denenen duruma göre a veya b değerini bir arttırmaktadır. Aslında kodumuz basit bir ikili ağaç (binary tree) oluşturmaktadır:

Önce 9 veya 7 ile başlanması ihtimalleri:

Sonra bu ihtimallerin de 7 veya 9 azalma ihtimalleri:

Yukarıda gösterildiği gibi her düğümden yine ikişer ihtimal indirerek bir alt seviyeye geçilebilir. Neticede 0 olana kadar yapılan bir aramadır ve 0 sonucuna birden farklı yoldan ulaşılabilir.

Kodumuz çalıştırıldığında çözüm olarak aşağıdaki sonuçları üretmektedir:

cozum : 7*4 + 9*8

cozum : 7*13 + 9*1

Gerçekten de problemin iki farklı çözümü bulunmaktadır.

Yukarıdaki kod basit bir hesaplama ile, 2′nin üstlerinin toplamı kadar adım hesaplamaktadır.

Bu değer yukarıdaki ağaçtan çıkarılabilir:

ilk düğüm için tek ihtimal 2 ⁰

ikinci seviye için iki ihtimal: 2 ¹

üçüncü seviye için dört ihtimal 2 ²

şeklinde gitmektedir ve örneğin problemimiz üçüncü seviyede çözülseydi (sonuç 0 olsaydı) o zaman karmaşıklığımız bu değerlerin toplamı olacaktı ve 2 ⁰ + 2 ¹ + 2 ² şeklinde hesaplanacaktı.

Bu değer, ikili ağaçlardan bilindiği üzere 2 ⁿ-1 şeklinde hesaplanabilir.

Görüldüğü üzere yukarıdaki algoritma O(2 ⁿ) değerinde bir karmaşıklığa sahiptir ve bu değer bir çok terimli (polynom) değildir yani algoritmanın karmaşıklık sınıfı np-tam (NP-Complete) olarak belirtilebilir. Ayrıca yukarıdaki k değeri için bir çözüm bulunmuştur ancak çözüm bulunamasaydı bu değer k terim için denenecekti. Yani 100 için çözüm yoksa bir yaklaşığı olan 99 için ardından iki yaklaşığı 98 için … Bu işlem hiç çözüm bulunamaması halinde k terim için denenecekti.

Yukarıdaki problem, dinamik programlama (dynamic programming) kullanılarak iyileştirilebilir. Bunun sebebi arama işlemi sırasında bazı sonuçların tekrar etmesidir. Örneğin yukarıdaki ikili ağacı aşağıdaki şekilde çizebiliriz:

Farka dikkat ederseniz, 93 – 9 = 84 ve aynı zamanda 91-7 = 84 olduğu görülür. Bu durumda aslında 84 değeri bir önceki kodda iki farklı durum için aranmaktayken şimdi tek bir durum için aransın istiyoruz. Elbette 84 sadece bir örnektir ve buna bağlı olarak çok sayıda tekrar eden değer bulunmaktadır.

Hesaplanan bu değerleri bir dizi (array) içerisinde tutup tekrar hesaplanmasını engellemek istiyoruz:

Yukarıdaki yeni kodda, bir dizi içerisinde tek döngü ile sonucu hesaplattık. Buna göre algoritmamız iki elemanlı bir diziyi kullanmakta, dizinin 0. elemanları 7lerin sayısını ve 1. elemanları ile 9ların sayısını saymaktadır.

Kodumuz ilk başta 0 için 0 tane 7 ve 0 tane 9 gerektiği gerçeği ile çalışmaya başlıyor. 14-23. satırlar arasındaki döngü basitçe i. terim için i-a ve i-b değerlerine bakıyor. Şayet i. terim için i-a veya i-b değerinde bir çözüm varsa (nereden geldiğini önemsemeksizin) bu çözüme bulduğu koşulu ilave ederek mevcut i değeri için çözümü kaydediyor. Şayet bu iki terim de bulunmuyorsa o zaman bir sonraki i değerine geçiyor.

Ekran çıktısı aşağıdaki şekildedir:

Son 20 satır görülmekle birlikte daha önceki satılar alıntılanmamıştır. Ayrıca son 20 satırda görüldüğü üzere, tamamına ait bir çözüm bulunmaktadır. Örneğin 88 sayısı için 7*10 + 9*2 = 88 sonucuna ulaşılmıştır. En son satırda ise 100 için 7*13 + 9*1 sonucu görülmektedir.

Görüldüğü üzere birden fazla sonuç olsa bile tek bir sonucu görmekteyiz bunun sebebi veri yapısının bir sonuç üretmek üzere tasarlanmış olmasıdır. Elbette daha farklı veri yapıları kullanılarak diğer çözümleri de gösteren sonuçlar elde edilebilir.

Yukarıdaki algoritmanın karmaşıklığı ise bir öncekine göre oldukça iyi sayılabilecek O(n) olarak bulunur. Bunun sebebi dizideki her elemanın üzerinden tek bir kere geçiyor olması ve dolayısıyla tek bir döngünün (koddaki 14-21 satırlar arası) çalışıyor olmasıdır.

569 views

Bu yazının amacı, JAVA dilinde bulunan ve grafiksel kullanıcı ara yüzü geliştirmekte kullanılan SWING kütüphanesine hızlı bir başlangıç yapmaktır.

Öncelikle Swing kütüphanesinin gelişiminden hızlıca bahsedelim. Swing kütüphanesi JAVA diline JDK 1.1 sürümünden sonra eklenmiştir. Daha önce AWT (Active Window Toolkit) ismi verilen bir kütüphane kullanmaktaydık ancak çok daha fazla ve gelişmiş özelliklerle gelen swing kütüphanesi neredeyse tamamen AWT yerine geçti denilebilir. AWT halen kullanılmakta, bunun en büyük sebebi JAVA’nın Visual Studio gibi geliştirme ortamlarından farklı olarak geçmişle uyumlu olmasıdır (back compatibility). Yani, örneğin 1997 yılında yazdığım bir kodu hala derleyip çalıştırabiliyorum.

AWT’nin bulunmasındaki diğer önemli bir faktör ise, Swing kütüphanesinin AWT üzerinde geliştirilmiş olmasıdır. AWT’den bu kadar bahsettikten sonra son olarak aynı projede hem AWT hem de Swing kullanmamanız gerektiğini, aksi halde ağır ve hafif bileşenlerin ekranda hatalı görüleceğini (heavy weighted, light weighted) söyleyerek Swing kütüphanesini anlatmaya başlayalım.

Swing kütüphanesi, javax altında bulunmaktadır ve bütün swing sınıfları (classes) javax.swing paketi ile başlar.

Örneğin, ekrana basit bir düğme koyarak uygulama geliştirmeye başlayalım.

Yukarıdaki kodun çıktısı, aşağıdaki şekilde bir pencereye yerleştirilmiş bir düğmeden (button) ibarettir:

Kodumuzda kullandığımız iki swing bileşeni olan JFrame ve JButton import edildikten sonra sınıfın bir JFrame olacağını, extedns JFrame yazıp JFrame sınıfını kalıtımla (inheritance) alarak belirtiyoruz.

Kodumuzda bulunan iki metottan ilki bir inşa fonksiyonu olup (constructor), this.add fonksiyon çağrılması ile JFrame içinde tanımlı olan add fonksiyonuna bir adet JButton parametre verilmiştir.

Klasik olarak swing kütüphanesinde, bir bileşenin diğer bileşenleri içinde barındırma özelliği bulunuyorsa (container) bu durumda add fonksiyonu, parametre olarak aldığı bileşeni, barındırıcı bileşene eklemektedir.

Kodun 5. satırında yapılan bu ekleme işleminde dikkat edilecek bir husus da, JButton bileşenini oluşturan ve new ile çağrılan yapıcı fonksiyonun (constructor) parametre olarak bir dizgi (string) almış olmasıdır. Bu dizgi, düğmenin üzerinde görülecek olan yazıdır.

Son olarak main fonksiyonunda, yeni tanımladığımız bu sınıftan bir nesne (object) oluşturarak bu objenin referansına sb ismini veriyoruz. Kodun 9. ve 10. satırlarında ise sırasıyla sb isimli bu nesneyi (ki artık JFrame özelliği taşıyan ve içerisinde bir buton olan nesnedir) paketliyoruz ve göstertiyoruz. Paketleme işlemini basitçe, bir pencerenin içerisindeki bileşenlerin sığacağı en ufak hali alması olarak düşünebilirsiniz. Gösterme işlemi ise bir bileşenin görünürlülüğünü (visibility) doğru yapmaktan ibarettir (true). Tersi şekilde görünürlülüğü yanlış (false) yapılarak bir bileşen gizlenebilir. Yine daha önceki sürümlerde bu işlem için sırasıyla show() ve hide() fonksiyonları da kullanılmaktaydı ancak JDK 1.3 sonrasında bu fonksiyonlar kaldırıldı.

Şimdi gelelim bu düğmenin tıklanması halinde eylemi algılamaya.

Yukarıdaki kodu yazıp denediyseniz tıklama eyleminin herhangi bir sonuç doğurmadığını görmüşsünüzdür. Bunun sebebi JAVA dilinde tanımlı olan herhangi bir eylemin sınıf içerisinde yer alamamasıdır.

JAVA dilinde eylemi üreten ve yakalayan nesneler farklı olabilir. Örneğin yukarıdaki örnekte düğmeyi tanımladığımız swingbuton isimli sınıf düğmeye tıklandığında devreye girebileceği gibi tamamen başka bir sınıf da devreye sokulabilir. Biz basit olsun diye ilk örneğimizde yine aynı sınıfta eylemi yakalayacağız. Bunun için öncelikle sınıfa bu özelliğin kazandırılması gerekir. JAVA dilinde bir sınıfın herhangi bir bileşen ile ilgili bir eylem yakalayabilmesi için ActionListener olması gerekir.

public class swingbuton extends JFrame implements ActionListener

şeklinde sınıfın tanımını değiştirerek bu sorunu çözebiliriz. Ancak, arayüzlerden (interface) hatırlanacağı üzere bir arayüzü (interface) sınıfa kazandırmanın (implements), bağlayıcı bir sonucu olmaktadır.

Kodumuzda yeni olan en büyük fark, sınıfta artık ActionListener arayüzünün implement edilmesidir. Bu arayüzün sınıfa uygulanması ile birlikte, sınıfta ” actionPerformed” isimli fonksiyonu bulundurma zorunluluğu ortaya çıkar. Nitekim yukarıdaki kodun 10-12. satırları arasında bu fonksiyon kodlanmış ve herhangi bir eylem olması halinde çalışacak olan bu fonksiyonun içerisinde ekrana “butona basıldı” mesajının yazılması sağlanmıştır.

Diğer bir ilave ise artık düğmenin bir eylem dinleyicisi olmasına olan ihtiyaçtır. Düğmemize basıldığında hangi sınıfın bu eylemi yakalacağını kodda belirtmemiz gerekir ki bu durum da 8. satırda kodlanmıştır.

Yukarıdaki kodun ekran çıktısı aşağıdaki şekildedir:

Birden fazla düğme bulunması halinde düğmeleri ayırt etmek için eylemin özel olarak koşullandırılması gerekir.

Kodun yeni halinde, düğmelerin tanımlandığı satırı sınıf geçerlilik alanına alarak actionPerformed fonksiyonu içerisinde hangi düğmeye tıklandığını kontrol edebiliyoruz. Bunun için parametre olarak gelen ActionEvent tipindeki e nesnesinin kaynağını okutan .getSource metodunu çağırıyor ve hangi nesneye eşit olduğunu sorguluyoruz.

Ayrıca kodda yapılan yeni bir ilave, birden fazla bileşeni aynı anda ekranda gösterebilmek için bir yayılım (Layout) eklenmesidir. Yukarıdaki kodda, 10. satırda bulunan komut, this ile ifade edilen JFrame nesnesinin yayılımının FlowLayout tipinde olacağını belirtmektedir. Bunun anlamı eklenen her bileşen, bir öncekinin sağına ilave edilecek, nihayet ekranda daha fazla sağa eklenecek yer kalmayınca aşağıya geçileceğidir.

Swing kütüphanesi kullanılarak mevcut bileşenler, yukarıda gösterildiği şekilde ekrana eklenip kullanılabileceği gibi, bileşenler üzerinde değişiklik yapılması da mümkündür. Örneğin bir swing bileşeni olan Jpanel üzerinde çizim yapmaya çalışalım:

Yukarıdaki kodda bulunan sınıf, Jpanel bileşenini miras almış ve bu bileşenin “paintComponent” isimli metodunun üzerine ezmiştir (override). Neticede Jpanel jf isimli Jframe’e eklenmiş ancak yeni çizim özellikleri ile görüntülenmiştir. Kodun ekran çıktısı aşağıdaki şekildedir:

paintComponet fonksiyonu yukarıda gösterildiği şekilde ezilerek (override) Graphics kütüphanesinden istenilen bir nesne, yukarıda gösterildiği şekilde ekrana eklenebilir.

Ayrıca JAVA’nın kuvvetli kütüphanelerinde birisi de Graphics2D kütüphanesidir. 2 boyutlu şekillerin bulunduğu kütüphane olarak tanımlayabileceğimiz bu kütüphane ile görsel pek çok işlem yapılabilir. Bu kütüphaneyi kullanmak için örnek kod aşağıda verilmiştir:

Yukarıdaki yeni kodda, paintComponent fonksiyonu altında, Graphics2D sınıfından türetilmiş bir nesne olan g2d nesnesine, şimdiye kadar kullandığımız ve klasik Graphics kütüphanesinin bir nesnesi olan g nesnesini tip inkılabı ile (type casting) atıyoruz. Bu sayede g2d nesnesinin fonksiyonlarını kullanabiliyoruz.

Kodda, dikdörtgen ve daire şeklinde iki nesne ekrana eklenerek gösterilmiştir. Kodun çıktısı aşağıda verilmiştir:

Aynı ekranda hem çizim hem de bileşen (component) kullanan kod (Ahmet beyin sorusu üzerine ekliyorum):

Sorunumuz, aynı ekranda hem çizim yapabilmek, yani Graphics kütüphanesini kullanmak, hem de java’nın bileşenlerinin (örneğin düğme (buton) veya yazı alanı (text areat) gibi ) kullanabilmek.

Bunu yapan örnek bir kodu aşağıdaki şekilde kodlayabiliriz:

Kodda, öncelikle bir JPanel sınıfı oluşturuyoruz. Basitçe JPanel miras alan bir sınıfımız var, ismi cizim ve bu sınıf içerisinde, yukarıda da anlatılan paintComponent metodunun üzerine ezere (method overriding) Graphics kütüphanesini kullanıyoruz (örnek olarak bir çizgi çizdirilmiştir).

Ardından main fonksiyonumuzu içeren bir sınıf kodlanmıştır. Bu sınıf içerisinde x nesne atıfı (object referrer) ile gösterilen bir JFrame oluşturulmuş ve bileşen yayılımı (layout) GridLayout olarak ayarlanmıştır. Kabaca ekran 2×2 boyutlarında dört parçaya bölünmüştür. Javada bu yayılıma ekleme yapıldığında sol üst köşeden başlanarak bileşenler eklenir ve ilk satır bitince aşağıya geçilir.

Buna göre sırasıyla eklediğimiz bileşenler, c ismindeki ve cizim sınıfından türetilmiş bir JPanel, satır içinde (inline) olarak türetilmiş bir cizim nesnesi, üzerinde “deneme” yazan bir düğme (buton) ve içinde “www.bilgisayarkavramlari.com” yazılı bir yazı alanı (JTextArea).

Ekranın çıktısı aşağıdaki şekildedir:

Görüldüğü üzere, ekranda çizim içerikli iki panel ve iki adet swing kütüphanesinden bileşen eklenmiştir.

570 views

Bazan biz insanlar için çok kullanılan kelimeler, tanımlanması en güç kelimeler haline dönüşebiliyor. Algoritma da sanırım bilgisayar bilimleri için benzer özellikte olan bir kelime.

Sanırım bu kelimeyi tanımlarken “bir dizi matematiksel adım” ifadesini kullanmak yerinde olur.

Bütün algoritmalar, matematiksel olarak ispatlanabilen ve dizilimi kesinlikle önem taşıyan ve bir metot anlatmasıdır.

Aslında bir kelimeyi başka bir kelime ile ifade etmek bir hatadır. Şayet iki kelime aynı şeyi anlatıyorsa, o zaman bir tanesi fazla demektir ama genelde algoritma için bu “metot” veya “sistem” kelimeleri sıkça kullanılıyor. Oysaki algoritma bunlardan farklı olarak bir, matematiksel bir dizilimdir. Evet, bir problemi çözmek için gerek metodu anlatır bu çözümde kullanılan sistemi gösterir ama atlanmaması gereken ispat edilebilirlik, karmaşıklığının ölçülebilirliği aslında bilgisayar bilimlerinin de temelini oluşturur.

Bu durumu bir örnek üzerinden açıklamaya çalışalım.

Örneğin sık kullanılan sıralama problemini (sorting problem) ele alalım. Elimizde bir dizi karıştırılmış sayı var ve biz bunları küçükten büyüğe doğru sıralamak istiyoruz. Bu durumda birisinin çıkıp ben bunları sıraladım demesi bir algoritma olmaz. Çünkü algoritmanın sistematik olarak probleme yaklaşması gerekir.

Ben bunları sıralayan bir sistem yaptım demesi de algoritma olmaz. Çünkü sistemin bütün adımlarını belirli olması ve analiz edilebilir olması gerekir.

Ben bunları sıralayan ve şu adımlardan oluşan bir sistem yaptım demesi de yeterli olmaz çünkü bu algoritmanın her durumda çalışacağının matematiksel olarak ispatlanabilmesi gerekir.

Ancak bu aşamadan sonra bir algoritmadan bahsediyoruz demektir ve tam da bu aşamadan sonra artık algoritmanın performansından bahsetmeye başlar ve algoritmamızın hafıza ve zaman ihtiyaçlarını ölçebilmeyi isteriz.

Yukarıdaki bütün bu tanımların yanında, bir algoritma elde ettikten sonra ayrıca bu algoritmanın uygulanabilir oluşu da tartışmaya açıktır. Örneğin geliştirilen algoritma, günümüz bilgisayarları için uygulanabilir olmayabilir. Bu durum algoritmamızı , algoritma olmakta çıkarmaz ancak uygulanamaz bir hale sokar (örneğin şu anda yeni yeni gelişen kuantum hesaplama algoritmaları buna birer örnek olabilir).

Ayrıca algoritmaların yaklaşımlarına göre sınıflandırılması da mümkündür. Hatta bu sınıflandırmaya uygun olarak algoritma geliştirilme metodolojileri de bulunmaktadır. Örneğin nesne yönelimli programlama (object oriented programming) , yapısal programlama (structured programming) veya fonksiyonel programlama (functional programming) , Emirli programlama (Imperative Programing), özdevinirli programlama (automat based programming) gibi.

566 views

Haberleşmede kullanılan bir terimdir. Bir kod kelimesi (code word), belirli bir teşrifatın (protocol, protokol) anlamlı en küçük parçasıdır. Her kod kendi başına tek bir anlam ifade eder ve bu anlam yeganedir (unique).

Aynı yaklaşım programlama dilleri için de geçerlidir. Her programlama dilinde bulunan her kelime tek bir anlam ifade eder.

Örneğin bir programlama dilindeki “if” kelimesi, bu dildeki kaynak kodda bulunan (source code) kod kelimesidir (code word).

Benzer durum herhangi bir haberleşme teşrifatında da olabilir.

Kod kelimeleri kullanıldıkları yere göre kanal kelimeleri (channel code words) veya kaynak kelimeleri (source code words) olarak isimlendirilebilir. İlki haberleşme ikincisi ise programlama tabiridir.

Ancak kavramsal olarak kaynak kelimelerinin veri sıkıştırma (data compression) veya veri güvenliği (cryptography) gibi alanlarda kullanılması da mümkündür. Örneğin uzun bir kelimeyi, daha kısa bir kelime ile ifade etmenin anlamı, bu kelimenin yerine geçen bir kaynak kod kullanılmasıdır.

Benzer şekilde kanal kodları, gürültülü ortamlarda veri iletişimini güvenli hale getirmek için gereksiz ilave bilgiler içerebilir. Yani kod kelimeleri, yerine kullanıldıkları anlamdan uzun veya kısa olabilmektedirler.

Veri güvenliği açısından da bir kod kelimesi, yerine kullanıldığı kelimeye dönüşü sadece belirli kişiler tarafından yapılabilen şifreli metindir.

197 views

Bilgisayar kodlamasında, bir kodun okunabilirliğinin düşük olması, yani kod takibinin zor olması durumunda, koda verilen isimdir.

Genellikle yapısal programlama dillerinde (structured programming languages) fonksiyonların bulunması ile birlikte GOTO veya JMP gibi, kodun içerisinde bir yerden başka bir yere atlayan komutların kaldırılması mümkündür.

Bu tip komutların kullanılması durumunda, kodun hem diğer programcılar tarafından okunabilirliği düşer, hem de kodun karmaşıklığı kestirilemez bir hâle gelebilir.

Spagetti kodu engellemek için 3 temel adım kullanılır:

1. Kodda bulunan ve koşula bağlanması istenen satırlar için if bloğu kullanılır
2. Kodda bulunan ve tekrarlanması istenen satırlar için döngü kullanılır
3. Kodda bulunan ve parametrize edilmesi istenen satırlar için (aynı satırların farklı değerlerle çalışması isteniyorsa) fonksiyon kullanılır.

Yukarıdaki bu üç adım tamamlandıktan sonra kodda herhangi bir GOTO satırı kalmamalıdır.

Ayrıca spagetti kodundan esinlenerek katmanlı mimarinin kullanıldığı ve projelerin birden fazla seviyeye bölünerek ele alındığı yaklaşımlara lazanya kod (lasagna code) ; veya özellikle nesne yönelimli programlama dillerinde (object oriented programming languages), program parçalarının birbiri ile olan ilişkisinin asgariye indirildiği ve neredeyse her parçacığın tek başına varlığını sürdürebildiği kodlama yaklaşımlarına da ravioli kod (ravioli code) isimleri verilmektedir.

197 views