Merhabalar,

Bir önceki yazımızda rails için jruby kullanımından ve windows üzerinde rails uygulamalarının servis edilmesi hakkında bir yazı yazmıştık. Bu yazıda jetty_rails’in sürümünün biraz eski olduğundan (son güncelleme tarihi 2009-07-08 20:28) bazı problemle karşılaştığımı yazmıştım.

Bu yazıda sizlere bu problemleri nasıl ortadan kaldıracağımızı anlatmak istiyorum.

1. Öncelikle jetty-rails’i standart gem yöntemleriyle yüklüyoruz.

jruby -S gem install jetty-rails

(daha fazla…)

Merhabalar,

Uzun süredir herhangi bir yazı yazmıyordum, arkadaşlar arasında konuşurken “neden yazmıyorsun” gibi sorulara maruz kaldım, “eee dedim yazacak pek bir şey kalmadıki, ben ruby veya yazılım ile ilgili konularda yazıyorum” dedim. “eğer herhangi bir konuda istek gelir ise o konuda yazarım ama, şimdilik böyle bir konu yok” dedim. Dedim de hemen cevabı yapıştırdılar suratımın orta yerine.. “Ruby dizileri gerçekten basit tutmuş, herhalde hız için.. Lisp veya fonksiyonel programlama dileri kadar esnek değil” dediler.. “Eneee” dedim :) bana yazı yazacak konu çıktı.

Şimdi öncelikle biraz konu ile ilgili kendimizi motive edelim; Neden dizi işlemleri bu kadar önemli ? Ya da diğer işlerden farkı ne olabilir ki ?

Öncelikle bir konuya açıklık getirmek gerekir, günümüzde yazılan programlar içerisinde pek çok durumda dinamik veya durağan veri kümeleri ile işlemler yapılıyor. Bu işlemler, yazdığımız programlar içerisinde performansı etkileyen en önemli etken olarak karşımıza çıkıyor. Ve günümüzdeki daha fazla veri üzerinden daha doğru bilgi edinme anlayışı nedeni ile dizilerin boyutları gün geçtikce artıyor ve üzerlerinde yapılan işlemler gün geçtik fazlalaşıyor, bu performans etkeni daha da önemli hale geliyor. Yanlış anlaşılma olmasın, burada bahsettiğim performans Şişirme Veri Girişi adlı yazıda bahsettiğim veri yoğunluğunun artması ile beraber ortaya çıkan performans kötüleşmesi.

Diziler üzerinde yapılacak işlemlerde öncelikle iki ana başlıkta değerlendirilmelidir;
1- Kolay kullanım,
2- En iyi algoritmanın kullanılması.

İkinci maddenin neden gerekli olduğu konusunda fazla söze gerek yok ama, birinci maddenin neden gerekli olduğu konusunda aklınızda sorular olabilir, bu soruları ortadan kaldırmak için şu şekilde bir açıklama yapabilirim. “Diziler üzerinde yaptığınız optimizasyonlar, algoritma seçimleri veya memory optimizasyonları” gerçekten zor ve uygulanması oldukça tartışmalı olabilir. Örneğin google’ın java dili için çıkardığı “Google Collections Library” buna örnek olarak gösterilebilir. Kolay kullanım ve entegrasyon yazılımcılar tarafından her zaman tercih edilir.

Peki Ruby tüm bunların karşısında bize güzel silahlar veriyor. Aslında tüm Ruby işlemlerinde olduğu gibi performans basitliğin gerisinde kalmış, yüzlerce kez söylediğim gibi “yazılımın çalışma hızı sonsuza giderken, geliştirme süresi sıfıra gitmeli” felsefesine ters değil.

data = [1,2,4,8,12,5,7,3,0,13,10,11,3]

# For..In
data.each { |x| puts "x=#{x}" }

# data içerisindeki tüm elemanları tek tek verilen
# blok içerisindeki işlemden geçirir ve sonuçlardan yeni bir dizi üretir.
puts data.collect { |x| x + x }

# For..In :) ile indexleri verir.. :) pek çok programlama dilinde
# karşılığı bulunmaz.
data.each_with_index { |x, index| puts "#{index}. eleman = #{x}" }

# 5'den büyük ilk kayıdı bulur.
puts data.detect { |x| x > 5 }

# 5'den küçük olanları true_data değişkenine,
# diğerlerini false_data değişkenine dizi olarak atar.
true_data, false_data = data.partition { |x| x < 5 }
puts true_data
puts false_data

# 5'den küçük olanları diziden çıkartır ve geri döner.
puts data.reject { |x| x < 5 }

# Varsayılan sıralama işlemi
puts data.sort

# Belirlenmiş kritere göre sıralama işlemi (string olarak sıralama)
puts data.sort_by { |x| x.to_s }
# veya
puts data.sort_by { |x| (x+5)/x }

Kolay gelsin.. :)

Merhabalar,

Bu yazımı aslında takip ettiğim bir kaç sitede yayınlanan blogları gördükten sonra yazma gereği duydum. Bahsettiğim bloglarda yer alan yazılar aslında basit anlamda Ruby’nin temel özelliklerinden bahsediyorlarda fakat bu yazılara çok farklı tepkiler geldi. Bu tepkiler içerisinde çok şaşıranlar.. hadi ya ben bunu bilmiyordum diyenler.. yaa demek böyle birşey varmış ama bu kötü vs..vs.. Ben de bu yorumları inceledikten sonra bu yazıyı yazmaya karar verdim.

Aslında konumuz Ruby’de sınıfların yapısı, özellikleri ile Ruby’nin sınıfları, kütüphaneleri ve bizim Component dediğimiz şeyleri nasıl gördüğüdür.

Öncelikle OO (Object Oriented) tüm dillerde olduğu gibi Ruby’nin sınıf tanımı Java’nın veya C#’ın sınıf tanımı ile aynıdır. Peki o zaman farklılık nerede :) ayrıntılarda.. şeytanın gizli olduğu yerde :)

public class HelloWorld extends ExampleSupport {

    private String execute() throws Exception {
        setMessage(getText(MESSAGE));
        return SUCCESS;
    }
}

Yukarıda belirtilen örnekte olduğu gibi execute isimli methodumuz private tanımlanmış, yani sadece HelloWorld sınıfı içerisinden kullanılabilir. Neden çünkü private…

peki bir de bunun benzerini Ruby’de gerçekleştirelim;

class HelloWorld < ActiveSupport
    private
    def execute
        SetMessage(GetText(MESSAGE))
        return SUCCESS;
    end
end

Yukarıdaki iki örnek birbirlerinin aynısı. Ama diyorum ya şeytan bu ayrıntılarda gizli elbetteki.. :) Tahmin ettiğiniz gibi Java dilinde herhangi bir esneklik yok tabiki.. private tanımladın.. private.. yok öyle yanar döner method tanımlama olayları...

Peki ya Ruby'de private olarak tanımlanmış bir methodu public yapabilirmiyiz.. elbette yaparsınız; private yerine public yazarsınız.. taaa taa oldu.. :) Diğer bir yöntem;

Parçalı sınıf (Partial Class) yönetimi ile yapılabilir.

class HelloWorld
    public
    def execute_public
        execute
    end
end

peki başka nasıl olur bu iş.. mesajlaşma ile olur.. şöyleki aslında bir methodu çağırmanın tek yöntemi o methodu direkt olarak çağırmak değildir. Ayrıca Reflection dediğimiz kavram ile de çağrılabilir (Java dünyasında da oldukça kullanılır).

helloWorld = HelloWorld.new
helloWorld.execute # Hata üretir.. execute halen private bir methodtur...
helloWorld.execute_public # Çalışır :)
helloWorld.send("execute") # Çalışır.. problem çıkarmaz.. Sınıfa execute adlı bir method çalıştırmasını söyler.
helloWorld.instance_eval("execute") # Çalışır.. problem çıkarmaz..

Görüldüğü gibi.. yazılımcıdır tüm kodların hakimi.. yoktur programlama dilinin mecburiyetleri.. :P

En son olarak benim tercih ettiğim yöntem; tabii private yerine public yazmak yerine.. :)

class HelloWorld
    public :execute
end

Yukarıda belirtilen bu yordam ile.. execute methodu artık public olmuştur.. hayırlı uğurlu olsun.. :D

Kolay gelsin..!

Merhabalar,

Öncelikle bu kadar uzun bir süre yazı yazmak ilginç oluyor. Bir aydan fazla bir süredir, nokta koymadığım bu günlüğe birşeyler yazmak biraz yabancı geldi açıkcası.

Bu yazıyı yazmam için beni birazcıkta olsa gaza getiren sevgili Mehmet DURAN kardeşime buradan teşekkür etmek isterim.. şak şakk şakk şakk.. javaayyyyy diyorum sana Mehmet.. :)

Öncelikle bu yazıdaki konumuzu belirteyim; Ruby programlama dilinde değişkenlerin nasıl tanımlandığı ve değişkenler üzerinde tip dönüşümlerinin nasıl olduğu.

Ruby’de değişkenler tanımlanırken herhangi bir şekilde tip belirtmenize gerek yoktur. İsterseniz Java veya C#’da yaptığınız gibi yapabilirsiniz ama o zaman biraz ayıp olur.. yuhananırsınız.. ohaa artık diyenler olabilir. Şöyledir yani;

intValue = 5
strValue = 'Hobaaa'
arrValue = []
hashValue = {}
regValue = \.*\
classValue = MyClass.new

Öncelikle programlama dillerinde değişken tiplerinin dönüşümü ve bu tiplerin ele alınmasını iki soru altında toplanabiliriz; Bu sorular
1. Tipler arasındaki dönüşüm nasıl gerçekleşir?
2. Değişken üzerinde işlem yaparken tip önemlimidir?

Öncelikle 1. soruyu ele alalım; “1. Tipler arasındaki dönüşüm nasıl gerçekleşir?”
El cevap: Eğer değişkeninizi bir tipten öteki tipe hödöö hödöö diye gönderiyorsanız, kullandığınız dil dinamik tip dönüşümüne sahiptir demektir. Eğer hödö hödöö diye değil de, daha efendi bir şekilde (örnek: ‘String.valueOf(55)’) yapıyorsanız durağan tip dönüşümüne sahipsiniz demektir. Değişkenlerinizi bir tipten öteki tipe değiştiremiyorsanız, ohaaa sizin o kullandığınız şey programa dili değil çin işkencesi demektir.

Programlama dillerine göre dinamik ve durağan tip dönüşümüne sahip olan diller;
Dinamik: Ruby, Python..vb.
Durağan: Java(yyyy), C#….vb.

İkinci soruyu ele alırsak; “2. Değişken üzerinde işlem yaparken tip önemlimidir?”
El cevap: Eğer siz bir karakter ile sayiyi toplamak isterseniz veya benim bir değerim var ama inan ben bile bilmiyorum ne olduğunu öyle yanar dönerli birşey işte.. (Basic’den Variant, C’den void) diyebiliyor iseniz, sizin için değişkenin tipi pekde önemli değildir. Yani değişkenler ile değişken tipleri arasındaki bağlantı ‘zayıf’tır. Her değişkenin veya her işlemin tipi olmasına gerek yoktur, diyebilirsiniz. Ama dersenizki ‘hadeee canım, tipsiz tipsiz değişkenmi olur, tipli adamın tipsiz değişkeni olmaz’ derseniz, tüm değişkenleriniz ile değişken tipleri arasında ‘güçlü’ bir bağlantınız var demektir.

Güçlü: Ruby, Java(yyyy), C#, C++…vb.
Zayıf: C, Basic, Java(yyy)Script….vb.

Peki Ruby’de bunlar nasıl oluyor da oluryor diyeceksiniz şimdi; İşte böyle oluyor..;

intValue = 5
puts 5 + intValue # problem yok.
puts "5" + intValue # büüürrrstt nereye biraderr..
puts "5" * "5" # bürrsttt yok daha neler..
# bir string(a) ile numarayı(b) çarptığınızda, ruby sizin a'yi b kez tekrarlamak istediğinizi zanneder.
puts "5" * intValue # Olur, bunun ruby'de karşılığı vardır.

Kolay gelsin..!

Merhabalar arkadaşlar,

Küçük bir yazı olacak, sadece sizlere JRuby’nin 1.0 Release Candidate 3 sürümünü duyurmak için bu yazıyı yazıyorum. Evet doğru duydunuz, JRuby takımı Microsoft’tan daha hızlı davranarak (yarış halen bitmedi, gerçi ortada bir yarış var mı onu da bilmiyorum ama :) ) RC3′de olsa 1.0 sürümünü dünyaya *nihayet* duyurdu.

Şimdi aklınızda soru işaretleri olabilir, Hemen sizlere JRuby’nin ne olduğunu anlatmaya çalışayım. Aslında sizler normal Ruby uygulamalarınızı yazıyorsunuz, çalıştırıyorsunuz..vs..vs. Fakat sonra canınız sıkılıyor, neden sıkılıyor bilmiyorum ama birden Ruby’de yazdığınız kodların Ruby’nin doğal ortamında değil de, Java Virtual Machine (JVM) üzerinde çalışmasını istiyorsunuz, nedenleriz şunlar olabilir;
- Performans amaçlı olabilir (bu konu tartışılır)
- Ruby’nin çalışmadığı fakat java’nın çalıştığı bir ortamda çalıştırmak için (Hangi ortam o ?? belki vardır, bilen varsa yazsın…)
- Müşterinizi ‘ben programı Java’da yazdım’ diye kandırmak için :)

galiba en geçerli neden bu sonuncusu :).

Ama sonuçta güzel, hoş ve desteklenmesi gereken bir olay. Ruby dili çok güzel ve akıcı bir yapıya sahip neden JVM’yi kullanmak istiyenler bu güzel dili kullanmaktan mahrum kalsınlar ki.. ciddiyim, espiri falan yapmıyorum, tamamiyle destekliyorum.

Rails kullanıcılarına önemli bir not, RoR altyapısı tamamiyle Ruby’de yazıldığı için JRuby yoluyla JVM üzerinde de dolayısı ile Java Application Server’lar üzerinde çalışabilir hale gelmiştir. Özellikle sağlam veri tabanı özelliklerini kullanan uygulamalarda bu sayede hız artışı sağlanabilir. (Henüz 1.0 RC3′ü inceleyemedim ama bazı kısıtlardan bahsediliyor fakat kesin bir şey söyleyemiyorum.)

Kolay gelsin…

Merhaba arkadaşlar,

Bugünkü yazımızda Struct ve OpenStruct yapılarından bahsedeceğiz. “Bu yapılara neden ihtiyacımız var ?”, “Var olan ‘class’ yapısı veya bu işlemlere benzer olan ‘Array’ ve ‘Hash’ yapılarını neden kullanmıyoruz ?”, “Bu kadar fazla öğrenmemiz gereken sınıf, yapı ve işlev varken neden bir de başımıza bu ikisi çıktı ?”, ve son olarak “Ne işimiz var kardeşim Struct ile falan, bunlar boş iş.. ne yapacan öğrenip de..!?” gibi soruları cevaplamak gerekir. Ama tüm bu sorulardan önce ben neden bu yazıyı yazıyorum onu anlatmalıyım sanırım. Bu yazıyı bu linkte yer alan bir yazıyı gördükten sonra yazmaya karar verdim. Bu yazıda blog sahibi arkadaş Ruby on Rails’de ActionMailler kullanımı sırasında kullanmış, çok da güzel kullanmış. Ben de kendi kendime ‘Ben de bunu bizimkilerle paylaşayım’ dedim. İyi ettim di mi ? ettim ettim.. :)

Hatta ve hatta çok da güzel bir snippet’da mevcut. Bir göz atmanızı tavsiye ederim.

‘Struct’ ruby içerisinde yer alan ‘Class’ benzeri bir yapı, aslında Class’dan türemiş farklı bir yapı. Şöyleki normalde yeni bir ‘class’ yaratmak istediğimiz de

class YeniSinif
attr_reader ...
attr_writer ...
attr_accessor ...

def ...
end

...
end

şeklinde ‘YeniSinif’ı yaratır ve bu sınıftan nesneler üretmeye başlayabiliriz. Struct, sadece veri taşımak için tasarlandığı için şu şekilde bir tanımlamaya ihtiyaç duyar;

# Temel Struct tanımı...
Adres = Struct.new(:posta_kodu, :sehir, :ilce, :semt, :mahalle, :apt_no, :apt_isim, :daire)

anlaşılacağı üzere, herhangi bir şekilde erişim belirleyicisi tanımlanamaz (private, protected, public gibi) tüm üyeler public’dir. Önemle belirtmem gerekirki, bu yeni oluşturduğum ‘Adres’ bir nesne değildir, bir sınıftır yani yeni bir türdür(type). Peki biz neden ruby içerisinde yeni bir tür(type) yaratmak istedik ? Örnekten de anlaşılacağı gibi, normal hayatta adres bilgisinde posta kodu, şehir, ilçe…vb bilgiler birbirlerinden ayrılamazlar ve mantıksal anlamda da bir birliktelikleri vardır. Elbette kullanmazsak programlarımızda çok büyük problemler çıkmaz ama bazı durumlarda bize çok büyük kolaylıklar sağlayabilir; örnek vermek gerekir ise; Struct kullanmadan adres yapısının kopyalanması;

yeni_posta_kodu = posta_kodu
yeni_sehir = sehir
yeni_ilce = ilce
yeni_semt = semt
...
...

peki Adres diye bir tür kullansaydık ve işlemleri bu tür üzerinden yürütseydik;

yeni_adres = adres.clone # Bu kadar.. :)

şeklinde küçücük bir kod parçası ile bu işlemi yapabilirdik. Peki hemen aklınıza gelebilir, zaten sınıf(class) yapısı mevcut ben struct yerine class kullanamazmıyım ? Elbette kullanabilirsin, class, struct’ın yapabileceği tüm özelliklere sahip temel ve en genel yapıdır. Struct sadece verileri tutmak için yapılmış ve bu iş üzerine yönelmiş class’ın alt sınıfıdır. Yukarıda da bahsettiğim snippet incelenecek olursa, bu konu daha rahat anlaşılır diye tahmin ediyorum.

Peki “Struct sadece verileri tutmak için yapılmış ve bu iş üzerine yönelmiş class’ın alt sınıfıdır” dedik, bu veri tutma işinde bizlere hangi özellikleri vermektedir. Struct, class’lardan farklı olarak bizlere bir Array veya Hash nesnesine erişir gibi içerisinde yer alan özelliklere erişimimizi sağlayabilir. Şöyleki;

adres = Adres.new()
# veya
# adres = Adres.new(34300, "İstanbul", "Fatih", "Cerrahpaşa", "ZZZZ ZZZ ZZZZ ZZ", 1, "Gonca", 18)
adres.posta_kodu = 34300
adres.sehir = "İstanbul"
puts adres[:posta_kodu] # 34300
puts adres["sehir"] # İstanbul
puts adres[1] # İstanbul
puts adres.members # üyelerin isimlerini verir.
puts adres.values # üyelerin değerlerini verir.

adres.each_pair do |key,value|
	puts key.to_s + ":" + value.to_s
end

Bir sonraki yazımda OpenStruct’u anlatmaya çalışacağım… :)

Kolay gelsin :)