Bir Java’cının Gözünden Ruby

Son zamanlarda en çok merak edip, öğrenmek istediğim diller arasında geliyor Ruby. Ruby herkesin dilinden düşürmediği, dinamik veri tipli ve her şeyin istisnasız nesne olduğu bir programlama dili. 1993 yılında Yukihiro Matsumoto tarafından geliştirilmiş. 2006 senesinde Ruby on Rails çatısının oluşturulmasıyla popüler bir web programcılığı dili olmuş.

Bu yazımda bir Java programcısının, yani benim Ruby dilini nasıl algıladığını, bu dilin kendisini nasıl hissettirdiğini sizlere aktarmak istiyorum.

Java’da her zaman şöyle bir şey yapmak istemişimdir:

[source language=’java’]
throw new Exception() if(abc….);
[/source]

Böyle bir yapı Java’da mümkün değil. Onun yerine her zaman şöyle bir şey yazmak zorundasınız:

[source language=’java’]
if(abc…)
{
throw new Exception();
}
[/source]

Tek bir satır ile ifade etmek istediğim bir düşünce için Java’da dört satır kod yazmam gerekiyor. Java’nın en büyük sorunlarından birisi bu. Bu zamanla Java’da yazılan programların okunamaz hale gelmesine sebep oluyor. İşin içine birde hata yönetimi (Exception Handling) girdi mi, kodu anlayana aşk olsun. Ruby’de dikkatimi çeken ve Java’da hasretini çektiğim if ve unless yapıları oldu. Ruby’de şöyle bir şey mümkün:

[source language=’ruby’]
puts ‘hello world’ if x==4
puts ‘hello world’ unless x==4
[/source]

[source language=’ruby’]
unless x == 4
puts ‘hello world’
end
[/source]

[source language=’ruby’]
order.calculate_tax unless order.nil?
[/source]

Belli bir düşünceyi Ruby’de olduğu gibi tek bir satır olarak ifade etmenin kodun okunabilirliği açısından çok büyük getirisi var. Bu satırı bir blok halinde yazmak elbette mümkün. Lakin bu ifade edilmek istenen düsüncenin kod arasında kaybolma rizikosunu artırıyor. Burada Ruby’nin takip ettigi filozofinin “ne kadar az kod, o kadar çok ifade edilmek istenen düsüncenin ön plana çıkması” olduğu belli oluyor.

Aynı sadelik Ruby’nin while ve until döngüleri için de geçerli:

[source language=’ruby’]
x = x+1 while x < 10 [/source] [source language='ruby'] x = x-1 until x == 10 [/source] Ruby'de her şey nesne: [source language='ruby'] >> 4.class
==> Fixnum
>> 4+4
==> 8
>> 4.methods
==> [“inspect”, “%”, “<<", "singleton_method_added", "numerator","*","+","to_i"......] >> true.class
==> TrueClass
>> false.class
==> FalseClass
[/source]

Java’da 4 rakamı int primitif tipine sahip iken, Ruby’de Fixnum tipinde bir nesne. 4.methods bu nesnenin sahip olduğu metotları sıralıyor. Ruby safkan bir nesneye yönelik programlama dili.

Ruby’de duck typing ismi verilen ilginç bir konsept uygulanmış. Bunun ne olduğunu açıklamadan önce bir Java örneği sunmak istiyorum.

[source language=’java’]
public void printFileName(File file)
{
if(file.exists())…
}
[/source]

printFileName() ismini taşıyan metodun file isminde bir parametresi bulunuyor. Metot gövdesinde bu parametrenin sahip olduğu sınıf tipine göre değişik metotlar koşturabilirim. Bunlardan bir tanesi exists() metodu. Bu metodu kullanabilmem için file ismindeki metot parametresinin File sınıfından türetilmiş olması gerekiyor, aksi taktirde exists() metodunu kullanamam. Java’da bir nesnenin sahip olduğu tip o nesnenin sınıfı tarafından belirleniyor. File tipinde olan bir değişken sadece File sınıfının metotlarını kullanabilir. Ruby’de durum farklı. Aradaki farkı görmek için bir Ruby örneğini inceleyelim:

[source language=’ruby’]
def copy_file(obj, dest_path)
src_path = obj.get_path
puts “Copying file \”#{src_path}\” to \”#{dest_path}\”.”
end
[/source]

copy_file() metodunun obj ve dest_path isminde iki tane parametresi bulunuyor. Bu iki parametrenin hangi tipte olduğu belli değil. Tipini, yani sınıfını tanımadığım bir nesnenin nasıl olurda obj.get_path() şeklinde bir metodunu koşturubilirim? obj nesnesinin ait olduğu sınıfta get_path() isminde bir metod olduğunu nereden biliyorum? Bilmiyorum, bilmek te zorunda değilim.

Ruby’de her şey nesne. Durum böyle olunca Ruby’nin kontrol etmesi gereken tek şey, kullanmak istediğim metodun nesnede var olup, olmadığı. Eğer kullandığım metodu Ruby nesnede bulamassa NoMethodError hatası oluşturur. Bunu da yakalayıp, gerekli işlemi yapmak zor değil. Buradan çıkardığımız sonuç şu: Ruby nesneleri üzerinde istediğim herhangi bir metodu koşturabilirim. Eğer nesnenin böyle bir metodu varsa, nesne istediğim şekilde davranış sergileyecektir. Aksi taktirde NoMethodError hatası oluşacaktır. Bu Ruby’de nesne tipinin sahip olunan sınıfa göre değil, nesnenin ihtiva ettiği metotlara göre belirlendiği anlamına geliyor.

Ruby’de Java ya da C# da olduğu gibi bir sınıf tanımlamak zorunda kalmadan şu şekilde bir metot tanımlanabiliyor:

[source language=’ruby’]
def bugunHavaSicakMi
true
end
[/source]

Ruby’de her fonksiyon bir değer geri veriyor. Eğer metodun son satırında return komutu kullanılmadı ise, o zaman son satırda yer alan değer geri veriliyor. Yukarıda yer alan örnekte geri verilen deger true olacaktır.

Bir array şu şekilde tanımlanabiliyor:

[source language=’ruby’]
>> hayvanlar = [‘Kedi’, ‘Fare’, ‘Yilan’]
==> [“Kedi”, “Fare”, “Yilan”]
>> puts hayvanlar
Kedi
Fare
Yilan
>> hayvanlar[0]
==> Kedi
>> hayvanlar[10]
==> nil
>> hayvanlar[-1]
==> “Yilan”
>> hayvanlar[0..1]
==> [“Kedi”, “Fare”]
[/source]

Var olmayan bir array elementine erişmek istediğimizde Ruby nil değerini geri veriyor. Java’da bu IndexOutOfBoundException hatası olurdu. Index olarak eksi değerler kullanıldığında Ruby arrayi sondan başa doğru görmeye başlıyor. Örneğin hayvanlar[-1] “Yilan”, hayvanlar[-2] “Fare” değerini geri verir.

Ruby ile ismi olmayan anonim fonksiyonlar tanımlanabiliyor. Bu anonim fonksiyon başka metotlara parametre olarak ta vermek mümkün. Aşağıdaki örnekte hello world ekranda üç sefer görüntülenir. Küme parantezi içinde yer alan kod aninim fonksiyondur.

[source language=’ruby’]
3.times {puts ‘hello world’}
[/source]

Anonim fonksiyonları parametrelendirmek mümkündür. Aşağıdaki örnekte each bir for döngüsü oluşturup, hayvanlar isimli listenin her elementini döngü içinde anonim fonksiyona parametre olarak vermektedir. Tek satırlık kod ile tüm listenin içeriğini ekranda görüntülemek münkündür.

[source language=’ruby’]
hayvanlar = [‘Kedi’, ‘Fare’, ‘Yilan’]
hayvanlar.each { |a| puts a}
[/source]

Java’da anonim fonksiyon tanımlamak için bir anonim class implementasyonu oluşturmak gerekiyor. Bir listedeki değerleri anonim bir fonksiyon tarafından ekranda görüntülemek için aşağıdaki şekilde Java kodu yazardık:

[source language=’java’]
package xxx;

import java.util.ArrayList;
import java.util.List;

public class Test {

final static List animals = new ArrayList() {
{
add(“dog”);
add(“cat”);
}
};

private static abstract class AnimalLister {
abstract void show(String animal);
}

public static void main(String[] args) {

each(new AnimalLister() {
@Override
void show(String animal) {
System.out.println(animal);
}
});
}

private static void each(AnimalLister animalLister) {

for (String animal : animals) {
animalLister.show(animal);
}
}
}
[/source]

Java’da bir sınıfa yeni bir metot eklemek için ya o sınıfı yeniden derlemek, ya AOP kullanmak ya da sınıfı bytecode seviyesinde manipüle etmek gerekiyor. Ruby’de mevcut bir sınıfa yeni bir metot eklemek çocuk oyuncağı:

[source language=’ruby’]
class Fixnum
def my_times
i=self
while i > 0
i = i-1
yield
end
end
end

3.my_times {puts ‘hello world’}
[/source]

Yukarıda yer alan Ruby örneğinde Fixnum isimli sınıfa my_times isminde yeni bir metot ekledik. Oluşturduğumuz bu yeni metodu 3.my_times şeklinde kullanabiliriz. JDK içindeki bir sınıfa doğrudan yeni bir metot eklemek istediginizi düşünün. Ruby’de mevcut her sınıfa yeni bir metot eklemek mümkün.

Java gibi nesneye yönelik programlama yapılan dillerde ortak kullanılan metot ve değişkenler kalıtım yolu ile altsınıflara verilir. Ruby’de bu mekanizma modüller aracılığı ile işlemektedir. Bir modül içinde fonksiyonlar ve değişkenler yer alır. Herhangi bir Ruby sınıfı tanımlı bir modülü kendi bünyesine kattığında, modül içinde yer alan tüm metot ve değişkenler sınıf tarafından kullanılabilir.

Aşağıda yer alan Ruby örneğinde ToFile isminde bir modül yer alıyor. to_f metodu to_s metodundan gelen değeri bir dosyaya ekliyor. to_s metodu modül bünyesinde tanımlı değil. Bu metodun modülü bünyesine katan sınıf tarafından implemente edilmiş olması gerekiyor. Ruby daha önce bahsettiğim duck typing yönetimi ile nesnenin to_s metoduna sahip olup, olmadığını kontrol ediyor.

Person sınıfı include ToFile ile modülü bünyesine katıyor ve to_f metodunu kendi bünyesinde tanımlıymış gibi kullanabilir hale geliyor.

[source language=’ruby’]
module ToFile
def filename
“object_#(self.object_id).txt”
end

def to_f
File.open(filename, ‘w’) {|f| f.write(to_s)}
end
end

class Person
include ToFile
attr_accessor :name

def initialize(name)
@name = name
end

def to_s
name
end
end

Person.new(‘özcan acar’).to_f
[/source]

Bu örneği Java’da aşağıdaki şekilde yazabilirdik. Java’da sadece tanımlı olan metotlar kullanılabilir. Ruby ToFile modülü örneğinde yer alan to_s metodunu kullanabilmek için bu metodun bir sınıf bünyesinde tanımlı olması gerekir. Aşağıda yer alan örnekte To_S isminde bir interface sınıf tanımlayarak, to_s metodunu bu sınıfa ekliyoruz. Soyut olan ToFile sınıfı bu interface sınıfı implemente ettiği için to_s metodunu tanır hale geliyor. Person sınıfı ToFile sınıfını genişlettiği için to_s metodunu implemente etmek zorunda. Person sınıfı ToFile sınıfını genişlettiği için to_f metoduna sahip oluyor. Person nesnesi tarafından to_f metodu koşturulduğunda, to_f metodu person nesnesi bünyesinde yer alan to_s implementasyona erişip, gerekli değeri edinebiliyor.

Ruby ile Java arasındaki en büyük fark, Java’nın kullanılan metotların hangi sınıflara ait olduklarından haberdar olması zorunluluğu. Ruby duck typing mekanizması ile bu zorunluluğu ortadan kaldırıyor.

[source language=’java’]
public interface To_S {

String to_s();
}
public abstract class ToFile implements To_S {

public String filename() {
return this.getClass().getSimpleName();
}

public void to_f() {
FileUtils.writeStringToFile(new File(“xxx”), to_s());
}
}
public class Person extends ToFile{

private String name;

public Person(String name) {
this.name = name;
}

@Override
public String to_s() {
return this.name;
}

public static void main(String[] args) {
new Person(“özcan acar”).to_f();
}
}
[/source]

Bu kısa tanıtım umarım Ruby diline ilginizi çekebilmiştir. Ruby dilinin ifade edilmek istenen düşüncenin çok az satır ile, düşüncenin kod kargaşası arasında kaybolmadan implemente edilmesini mümkün kılması beni etkileyen en önemli özelliği oldu. Benim için ön planda olan kodun nasıl yazıldığı değil, düşüncenin kod olarak nasıl ifade edildiğidir. Programcılıkta zamanla ilgi alanı problem çözme, algoritma kullanımı vs. gibi konulardan, düşüncelerin sade ve çok kısa kod parçası olarak kodlanabilmesi yönüne kaymaktadır. Bu en azından benim için geçerli olan bir durumdur. Bu sebepten dolayı Ruby gibi düşüncelerin sade ve yüksek bir soyutluk seviyesinde ifade edilmesine izin veren dilleri tercih ederim.


EOF (End Of Fun)
Özcan Acar

Alet İşler, El Övünür

Birçok meslekte araç ve gereç sahibi olmadan iş yapmak mümkün değildir. Günlük hayatımızda da birçok araç ve gereci kullanırız. Örneğin bir resmi duvara asabilmek için bir çivi ve bir çekic kullanırız. Çoğu zaman işimizi gördükten sonra başarımız ile övünür, bir sonraki ihtiyacımıza kadar kullandığımız araçları hatırlamayız.

Araçlar zamandan tasarruf etmek ve işimizi kolaylaştırmak için vardır. Bazı araçlar olmasaydı, isteğimiz işi yapmamız bile mümkün olmazdı. Çekiç sahibi olmadan duvara çivi çakmak mümkün değildir. Bunun için bir taş parçası bile kullansak, kullandığımız bu taş parçası bir araç haline dönüşür.

Yazılımcı olarak ta günlük hayatımızda birçok araç kullanırız. Bunların başında kod yazmak için kullandığımız IDE (Integrated Development Environment) araçları gelir. Ben günlük işlerimde genellikle Eclipse IDE’yi tercih ediyorum.

Araçlar işimizi kolaylaştırmak ve zamandan tasarruf etmek için var demiştim. Ne yazık ki bazı yazılımcılar bunun bilincinde değiller. Gerekli araç ve gereçleri kullanmalarına rağmen, zamandan tasarruf ettikleri söylenemez, çünkü kullandıkları araçların hakkını veremiyorlar.

Kod yazmak için kullanılan bir aracın en verimli kullanım şekli, bazı aksiyonlar (örneğin yeni bir sınıf oluşturma, yeni bir metot oluşturma) için kısa yol tuşlarını tanımak ve uygulamaktır. Örneğin bir interface sınıfını implemente etmek istediğimizde, implementasyon sınıfında tek tek metot gövdelerini oluşturmak yerine Eclipse altında STRG+1 tuşlarına baştıktan sonra Add unimplemented methods seçimini yapmak yeterlidir. IDE otomatik olarak interface sınıfı bünyesinde yer alan her metot için implementasyon sınıfında gerekli metot gövdesini oluşturacaktır. Bu işlemi elden yapmak çok büyük bir zaman kaybıdır. Bu aracı kullanıp, hakkını verememektir.

Bir yazılımcının en önemli araçlarından birisi kullandığı IDE olduğuna göre, IDE’nin sundugu imkanlar doğrultusunda yaptığı işlemlerin sürelerini kısaltmanın yollarını aramalıdır. Bunun yolu kısa yol tuşu hakimiyetinden geçmektedir. Bunun yanısıra fare kullanımından sakınmalıdır. Fareye uzanan el bir thread context switch gibidir. İş akışını bir an için bile olsa böler. Programcının en önemli aracı klavyesidir. Klavyeye ek olarak fareyi kullanması, klavyenin hakkını veremediği anlamına gelir. Aynı işi tek bir araç ile yapabilecekken, iki değişik araç kullanarak zaman kaybeder.

Bir başka zaman kaybı türü de yazılımcının on parmak kod yazamamasıdır. Yazılımcının kod kaynağına bakacağı yerde, x tuşu nerede diye klavyeye bakması context switch’dir. Devamlı bu şekilde çalışmak yazılımcıyı hem yorar, hem verimini düşürür hem de zaman kaybetmesine neden olur. Bu sebepten dolayı her yazılımcının on parmak kod yazabilme yetisini geliştirmek için çalışma yapması zaruridir.

Yazılım otomasyon demektir. Otomasyonun olmadığı yerde zaman kaybı var demektir. Ant ya da Maven ile otomatik sürüm oluşturmak yerine, bu işi her defasında elden yapmaya çalışmak çok büyük zaman kaybıdır. Yazılımcının bu noktada zamanının belli bir kısmını sürüm oluşturma araçlarının kullanımını öğrenmek için harcaması, bu yatırımın sürümlerin daha hızlı ve otomatik oluşturularak amortize olmasını sağlayacaktır.

Kullandığı araçlara hakim olmayan bir ustaya kim usta gözüyle bakar? Elimizin övünmesini istiyorsak, kullandığımız araçlara hakim olduğumuzu gösterelim.

Eklenti (17:51 . 22.02.2013):

Bir yazılımcı için kullandığı en önemli araç bilgisayarıdır. Klasik bir iş bilgisayarları okuma kafası dakikada 5000 ila 7000 arasında dönen sabit disklere sahiptir. Taş devrinden kalma bu teknoloji yüzünden yazılımcılar hergün dakikalar ya da saatlerle ölçülebilen zaman kaybına uğruyorlar. Windows gibi bir işletim sistemi ve yetersiz hazıfa (ram) kapasitesi buna eklendiğinde yazılımcıların mesaileri kabusa dönüşebiliyor. Bunun önüne geçmek için yazılımcını 64 bit genişliğinde, SSD sabit diskine ve en az 8 GB hazıfa alanına sahip bir bilgisayar kullanmalıdır. Bunun altindaki her konfigürasyon işletim sisteminin akışkanlığını bozarak, yazılımcının belli aktiviteler için bekleme süresini artıracaktır ve verimliliğini düşürecektir.


EOF (End Of Fun)
Özcan Acar

Cahilliğime Verin

BTSoru.com‘da bir soru sorulmuş. Tüm soruları kontrol ederek ihtiyaç durumunda başlığı, içeriği ve etiketleri düzenlemeye çalışıyorum. Bu soruyu incelerken verilen kod örneğini Struts kodu zannettim ve sorunun etiketini Struts olarak değiştirdim.

Kısa bir zaman sonra soruya bir yorum yapan bir arkadaşımızdan bir uyari e-postası aldım. Arkadaş iletisinde etiketin asp.net-mvc olmasının daha anlamlı olacağını bildiriyordu. İlgisi için kendisine teşekkür ettim ve etiketi asp.net olarak değiştirdim. Bilmediğim bir şey vardı: asp.net ve asp.net-mvc iki değişik şeydi.

Kısa bir zaman sonra aynı arkadaşımızdan tekrar bir uyarı iletisi aldım. Çok kibar bir şekilde asp.net ile asp.net-mvc’nin iki ayrı teknoloji olduğunu belirtiyordu. Özür dileyerek sorunun etiketini asp.net-mvc olarak değiştirdim.

Buradan çıkarabileceğimiz bazı dersler var. Bunlar:

  • Yanlış olanı düzeltmek için çaba sarfetmek her programcının asli görevlerinden birisidir.
  • Sesini yükseltip, yanlışlara işaret edebilmek cesaret ister. Bunu yapabilen yaptığı işin hakkını veriyordur.
  • Birilerinin bir şeyler hakkında daha fazla bilgiye sahip olma ihtimali yüksektir. Her şeyi bilirim edasıyla hayatın içinden geçip gitmek abesle iştigaldir.
  • Daha iyi bilenin yakasına yapışmak ve ondan öğrenmek farzdır. En kolay öğrenme yöntemi budur.
  • Bu konu hakkında bilgim yok, ama öğrenebilirim demek bir erdemdir. Bilgisi olmadığı halde bilgisi varmış gibi davranmak ahmaklıktır.
  • Tatlı dil yılanı deliğinden çıkarır. Bahsettiğim arkadaş kendi bilgisel üstünlüğünü ortaya koymak için kühtahça bir ileti de gönderebilirdi. Bunun yerine çok nazik ve kibar bir üslup ile yanlışa işaret etmeyi tercih etti. İki şekilde de kazanan o oldu: hem isteğinin yapılmasını sağladı, hem de efendi bir üsluba sahip oldugunu ispatladı.

Hz. Ali’nin güzel bir sözü var: Bana bir harf öğretenin kırk yıl kölesi olurum… Ditto!


EOF (End Of Fun)
Özcan Acar

Açık Sözlü Programcı

Programcı takım arkadaşı ile kodu gözden geçirme (code review) seansı yapıyor. Kodun içinde bulunduğu durumdan hoşnut değil, lakin bunu takım arkadaşına söylemiyor. Arkadaşının yanlış anlamasından mı korkuyor?

Tüm yazılımcılar iterasyon sonunda bir araya gelerek geri bakış (retrospective) seansı yapıyorlar. Bazı programcılar boğazlarına kadar dolmuşken, bunun nedenini takım arkadaşlarıyla paylaşmıyorlar. Çok mu sabırlılar?

Günlük stand-up toplantı yapılırken bazı programcılar planın gerisinde kaldıklarını, üzerinde çalıştıkları kullanıcı hikayesinin zamanında tamamlanmasının münkün olmadığını söylemiyorlar. Ekip arkadaşları önünde küçük düşmekten mi korkuyorlar?

Programcı başka bir ekip arkadaşının yazdığı kodu değiştirmeye çekiniyor. Aynı şeyin kendi yazdığı kodun başına gelmesini mi istemiyor?

Verdiğim örneklerin hepsinde bir tikanıklık ve blokaj söz konusu. Bahsettiğim programcılar samimi ve açık sözlü değiller. Bu ne yazık ki çevikliği öldüren, şeker hastalığı gibi çok sinsi bir şey. Çevikliğin temel değer sistemini cesaret, iletişim, geribildirim ve basitlik oluşturuyor. Bunların olmadığı yerde çevik olunması imkansız.

Kimsenin etlisine, sütlüsüne karışmamak çevik süreci sabote etmek gibi bir şeydir. Herkes açık sözlü olma cesaretine sahip olmayabilir. Ama bunun için gerekli ortam oluştuğunda açık sözlü olmamak için de bir sebep yoktur. Bir retrospektive seansında kimseyi suçlamadan ve küçük düşürmeden yanlış giden şeyler üzerinde konuşulabilir. Fikir birliği sağladıktan sonra yolunda gitmeyen şeyleri tekrar rayına sokmak zor değildir. Burada önemli olan samimi olmak ve yanlış giden şeyleri açık sözlülükle dile getirmektir.

Yazılım bir ekip işidir. Bireyin başarısı takımın başarısıyla ya da başarısızlığıyla doğrudan orantılıdır. Tüm takım aynı bot içinde oturduğuna göre, botun ilerleyebilmesi için herkesin aynı şevk ile kürek çekmesi gerekir. “Bot su alıyor, ama bana ne“, “bazı arkadaşlar kürek çekmiyor, benim derdim değil“, “bazı arkadaşlar kürek çekme tekniğine tam hakim değiller, kim uğraşacak şimdi onlarla” gibi düsüncelere sahip olmak botu hedefine ulaştırmaz.

Samimiyet ve açık sözlülük programcının takım içindeki saygınlığını artırır. Bunun tersi durumunda halka en zayıf yerinden kopacaktır. O en zayıf nokta samimi ve açık sözlü olmayan programcının kendisidir. Bunu herkes bilmesede kendisi çok iyi bilir.


EOF (End Of Fun)
Özcan Acar

Java Generics Get ve Put Prensibi

Java Generics and Collections kitabında Get and Put isminde bir prensipden bahsediliyor. Java Generics wildcard kullanımı bu prensip takip edildiğinde daha kolaylaşıyor. Prensip şöyle:

Eğer bir yapıdan (liste, map vs.) nesne ediniyorsanız (get) extends wildcard, bir yapıya nesne ekliyorsanız (put) super wildcard kullanın. Bir yapı üzerinde bu iki işlemi birden yapıyorsanız, o zaman wildcard kullanmayın.

Bunu bir örnek ile açıklayalım. Aşağıdaki metot bir listeden diğer bir listeye nesneleri kopyalamak için kullanılan jenerik bir metot.

[source language=”java”]
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
dest.set(i, src.get(i));
}
}
[/source]

copy metodunun ilk parametresi nesnelerin kopyalanacağı, yani put yapılacak olan liste, ikinci parametresi nesnelerin alındığı, yani get edildiği liste. Şu şekilde bir listeyi diğer bir listeye kopyalayabiliriz:

[source language=”java”]
List<Object> objs = Arrays.<Object>asList("String", 1, 3.14);
List<Integer> ints = Arrays.<Integer>asList(1,2);
copy(objs, ints);
[/source]

dest isimli parametre put işlemi yapıldığı için super wildcard’ını, src isimli parametre get yapıldığı için extends wildcard’ını kullanıyor.

Bir iterator kullanıldığında bir yapıdan get işlemi ile değerler edinilir. Bu durumda extends wildcard kullanılmalı. Aşağıdaki örnekte sum metodu bir listede yer alan Number sınıfı ve altsınıflarından oluşan nesnelerin değerlerini topluyor. Buna göre bu metodu sum(Arrays. asList(1, 2)) ya da sum(Arrays. asList(1.1, 2.2)) şeklinde koşturmak mümkün. Eğer extends wildcard kullanılmasaydı Integer ya da Double nesneler ihtiva eden bir listeyi sum metoduna parametre olarak vermek mümkün olmazdı.

[source language=”java”]
public static double sum(Collection<? extends Number> nums) {
double s = 0.0;
for (Number num : nums)
s += num.doubleValue();
return s;
}
[/source]

EOF (End Of Fun)
Özcan Acar

Programcılık Çıtası Yükseliyor

Ben Java’nın ilk günlerinden beri bu dili kullanan bir programcıyım. 1998 senesinin bir günü kampüste laflarken bir arkadaşım yeni haberini aldığı Servlet teknolojisinden bahsetmişti. Bugün gibi hatırlıyorum: “vay… demek Java ile appletler harici web programcılığı yapılabiliyor….” demiştim. Java ile geçirdiğim ilk yıllarda hakim olmam gereken konular JDBC, Reflection, RMI ve Servlet gibi teknolojilerle sınırlı idi. On beş sene sonra durum çok farklı! Başlangıçta küçük bir havuzda yüzerken, şimdilerde kocaman bir okyanusun içindeyim ve bu okyanusun ucu, bucağı yok.

Java dili eklenen her yeni teknoloji ile günümüzde bir platform haline geldi. Artık Java dili bu platform üzerinde kullanılan dillerden sadece bir tanesi. JVM üzerinde koşturulabilen Scala, JRuby, Groovy, Clojure gibi birçok dil mevcut.

Bundan beş, altı sene öncesine kadar tipik bir Java programcısı JMS, JTA, EJB, JAXB, JSF, JSP, JAX-WS gibi çeşitli Java çatılarına hakimliği ile övünebilirken, durum bugün çok daha değişik. İsmi geçen çatılar bugün bir Java programcısının repertuarında var olması gereken şeyler. Hepsine hakim olmak bir marifet değil, bir zorunluluk haline geldi, çünkü piyasa bir Java programcısından bunu bekliyor.

Durum sadece bununlu sınırlı değil. Artık JVM üzerinde çalışabilen dört yüze yakın programlama dili mevcut. Bunların başında daha önce ismini verdiğim Scala, Clojure, JRuby, Groovy ve Jython geliyor. Doğal olarak piyasada bu dilleri kullanarak geliştirilen proje sayısı göz ardı edilmeyecek kadar fazla. Twitter, LinkedIn ve FourSquare Scala dili ile geliştiriliyor. Bu durumda klasik bir Java programcısının bu dillere yönelme haricinde fazla bir alternatifi kalmıyor. Bu ekstra öğrenim yükü demek.

Bu durum sadece Java dilini kullanan programcılar için geçerli değil. Net platformunu kullanan programcılar da birçok değişilik ile baş etmek zorundalar. Aynı şey mobil programcılar için de geçerli. Programcılar gidişatı tam anlamıyla kavrayabilmek için ilgi alanlarına giren her şeyi tam teşekküllü takip etmek zorundalar. Bu programcının şimdilerde onlarca blog sitesini takip etmesi, yüzlerce kitap okuması, onlarca yeni programlama dili öğrenmesi anlamına geliyor. Programcının sahip olduğu bilgilerin yarı ömrü aylarla ölçülür oldu.

Bugün profesyonel programcı olarak çalışan insanların çok büyük bir kesimi imperatif dilleri kullanıyor. Bu dillerde eğitim aldılar ve tüm düşünce yapıları bu dillerin sunduğu yapılar üzerine kurulu. Bu programcıların çoğu bugünlerde büyük bir kültür şoku yaşıyorlar. Son günlerde fonksiyonel dillere olan ilgi çok artmış durumda. İmperatif bir dünyadan gelen bir programcının fonksiyonel dillere adapte olması ve anlaması kolay değil. Closure, lambda, higher order functions, functions as first class citizen, recursiv programming, pure functions gibi terimler imperatif programcıların kafasını karıştırmış durumda. Ama piyasa bu konseptleri anlamış programcılar istiyor. Er ya da geç imperatifcilerin fonksiyonel programcılık konseptlerine vakif olmaları gerekiyor. Programcılara yönelik beklentiler yükselmiş durumda.

İs görüşmelerinde de büyük bir değişimin yaşandığı bir gerçek. Eskiden piyasada programcı bulduklarında öpüp, başına koyan iş verenler, şimdilerde adayları intensif görüşmeler ve testler ardından işe alıyorlar ya da almıyorlar. İş bulmak zorlaştı, çünkü bir programcıda aranan vasıflar değişti. Artık CV’de yer alan kelimelere göre programcı alımları son bulmuş durumda.

İsteyenin parmağını kaldırıp, “Java kelimesinin nasıl yazıldığını biliyorum, ben programcıyım” diyerek iş buldugu devir artık son buldu. Günümüzde programcı olmak ve kendisini programcı olarak yetiştirebilmek çok güç bir hale geldi. Vakıf olunması gereken çok çesitli konu ve konseptler mevcut. Bu yeni süreç artık işine muazzam derecede hakim programcılar doğuracak. Bu işi kıvıramayanlar daha işin başında iken elenip, piyasadan uzak tutulacaklar, çünkü piyasada onların yapabileceği iş olmayacak.

Programcı olma çıtası on sene öncesine göre çok yükseldi ve yükselmeye devam ediyor. Bu güzel bir gelişme. Artık akla, karanın ayrıştığı bir dönemdeyiz. Programcılık hafife alınabilecek ve yarım yamalak bilgi ile yapılabilecek bir iş değil. Bu işi çalışma sahalarındaki her şeyi en ince detayına kadar anlamış, öğrenme kapasiteleri yüksek, değişikliklere adapte olan ve yeniliklerden çekinmeyen programcılar yapmalı. Çıtanın yükselmesi doğal bir seleksiyon yöntemi. Er ya da geç gerçekleşecekti. Bu işe gerçek anlamda gönül verenler ilerleyebilecek, para icin yapanlar ise çok kısa bir zamanda kendilerine baska çalışma alanları aramak zorunda kalacaklar, çünkü bu değişime ayak uydurmaları imkansız.

İyi programcıların ağaçta yetişmediği bir gerçek. Bir programcının iyi bir programcı olabilmesi için çok okuması, öğrenmesi, öğrendiklerini uygulaması ve yenilikleri takip etmesi gerekiyor. Bu vasıflara sahip olan programcıları tanımak zor değil. Sahip olmayanları da tanımak zor değil. Bu işin başında olanlar iş bulamayacak tezini savunmuyorum. Yaşadığımız bu gezegende bugün düne nazaran çok daha fazla programcıya ihtiyaç var. Ama bu ihtiyacın gözü eskisi gibi kör değil. Neyi, hangi tip programcıyı aradığını iyi biliyor ve seçimini ona göre yapıyor. Bu işe gönül verenler, bu işin başlangıcında da olsalar bu ihtiyaca her zaman cevap verebilecek yeteneklere sahip olacaklar. Zaman içinde bilgilerine bilgi, tecrübelerine tecrübe katarak çok daha iyi programcılar olacaklar. Çatının yükselmesi onlar için bir sorun olmayacak, çünkü çatıyı yükselten kendileri olacak. Gelecekte bu tip programcılar ile çalışmak çok ama çok zevkli olacak.

EOF (End Of Fun)
Özcan Acar

Organizasyonel Değişim

Yazılım camiasında son zamanlarda dikkat çeken bir değişim furyası var. Cevabı aranan soru şu: Yazılım ekibi nasıl daha verimli hale getirilebilir? Bu aslında organizasyonel bir değişimin gerekli olduğu bilincinin oluştuğu anlamına geliyor. Yöneticiler ekiplerini daha çevik hale getirmek için çeşitli yöntemlere başvuruyorlar. Bunların başında örneğin ekibin topluca eğitilmesi geliyor.

Her eğitim şüphesiz ekibe ve bireylerine bir şeyler katıyor. Ama bunu ölçmek çok zor. Bunun yanı sıra cevaplanması gereken bir soru daha var: Eğitim ile istenilen değişiklik sağlanabilir mi?

Alınan eğitimler değişimin sadece başlangıcı niteliğinde olabilir. Bunu yeni bir dil öğrenme süreci ile kıyaslayabiliriz. Öğrenilen her yeni kelime, kelime hazinesini genişletir. Pratik yapılarak kullanılmayan bir kelime hazinesi hiçbir şey ifade etmez ve değeri yoktur. Yazılım ekiplerinin tükettikleri eğitimler genelde sahip oldukları metot hazinelerini genişletmekle birlikte, bu metot hazinesinin günlük işlerde pratiğe dökülmemesi istenilen değişimi sağlayamamaktadır. Değişime gitme çabalarının son bulduğu nokta burasıdır.

Değişim yönetilmesi gereken bir süreçtir. Tesadüflere ve ekibin inisiyatifine bırakılabilecek bir şey değildir. Bir yazılım ekibi rasyonel düşünebilen, soyutlayabilen, problem çözme yetisi gelişmiş bireylerden oluşabilir. Ama unutmamak gerekir ki ekibi oluşturan bireylerin kendilerine has alışkanlıkları vardır. Değişim için gerekli baskı azaldığında ya da ortadan kalktığında bireyler bu alışkanlıklarına geri dönerler. “Ekip belli bir eğitimi aldıktan sonra artık çalışmalarını bu yönde adapte edecektir, dışarıdan müdahale etmeye gerek yok” şeklinde düşünmek bir yanılgıdır. Bu şekilde ekibin inisiyatifine bırakılan değişim süreci başladığı gibi son bulur.

Bunun örneklerini danışmanlık hizmeti verdiğim şirketlerde gördüm. Örneğin bir defasında yazılım sürecini daha çevik hale getirmek için ekibin test güdümlü yazılım eğitimi alması tavsiyesinde bulundum. Ekip gerekli eğitimi aldı. Ekip içinde test yazma duyarlılığı arttı, lakin ekibin hiç bir bireyi gerçek anlamda test güdümlü yazılım yapmadı. Kısa bir zaman sonra yazılımcılar eski davranış biçimlerine geri döndüler. Şimdi yine eskiden olduğu gibi kod yazıyorlar. İstenilen değişimin gerçekleşebilmesi için şu adımların atılması gerekir(di):

  • Değişim bir süreç olarak algılanmalı ve buna göre de yönetilmelidir. Bu birilerinin süreç gidişatından sorumlu olması anlamına gelmektedir. Değişikliğin meydana gelmesinden sorumlu olan bu şahıs ekipten gerekli geri bildirimi alarak, değişikliğin hangi safhada olduğunu takip etmek zorundadır. Bu geri bildirim alınması gereken önlemlerin tespiti ve planlanması açısından önem taşımaktadır.
  • Değişimin gerçekleşmesi için ekip içinde değişimin yaşanması gerekir. Ekip liderinin alınan eğitim sonrasında kazanılan yeni yetilerin uygulanmasını teşvik ve kontrol etmesi gerekir. Kendisi takım arkadaşlarına iyi bir örnek olarak, değişimi yaşadığı sinyalini vermelidir. Körle oturan, şaşı kalkar misali, ekip bireyleri liderlerini takip edip, değişimin vücut bulmasını sağlayacaklardır.
  • Ekip içinde bilgi ve becerilerin hızlı ve eşit bir şekilde dağılmasının en kolay şekli programcıları eşli programlama yapmasıdır. Eşli programlama programcıların kendilerini ve karşılıklı birbirlerini kontrol etmelerini mümkün kılar.
  • Değişimi getirecek sürecin doğru işleyip, işlemediğini kontrol etmek için ekip dışından destek alınmalıdır. Belli aralıklarla uzman bir koç gidişatın doğru olup, olmadığını kontrol edip, gerekli rota düzenlemesini yapabilir. Süreç tıkandığında da koç oluşan düğümleri çözecek ve değişime giden sürecin önünü açacaktır.
  • Değişim sürecinin tamamen durduğu anlardan birisi programcıların kriz anında eski alışkanlıklarına geri dönmeleridir. Bu ne yazık ki önlenmesi çok zor bir durumdur. Daha önceki bir yazımda bahsetmiştim. Kriz anlarında otomatik olarak devreye giren davranış biçimlerinin önüne geçmenin tek yolu pratik yapmaktan geçmektedir. Programcı kod kata ismi verilen kod pratiklerini devamlı yaparak, krizle ortaya çıkan verimsiz davranış biçimlerini zamanla beyninde silebilir. Kod kataları değişim sürecinin bir parçası haline getirilmelidir.

Yazılımcılar yetenekli insanlar. İstenilen bir şeyleri kavramaları uzun zaman almaz, lakin uygulamada zorluk çekebilirler. Yönetimin yazılım ekibine gerekli desteği sağlaması ve bu sorumluluğu onlarla paylaşması, değişimin daha kolay gerçekleşmesini kolaylaştıracaktır.

EOF (End Of Fun)
Özcan Acar

Türkiye Yazılımcı Raporu 2012

Bu rapor Kurumsaljava.com‘da hazırladığım yazılımcı anketinden edindiğim verileri ihtiva etmektedir. Ankete son beş ay içinde beş yüze yakın yazılımcı katıldı. Ankette yer alan soruları yazılımcıların çalışma yöntem ve süreçlerine, kullandıkları araçlara ve bu meslekten beklentilerine ışık tutacak şekilde şekillendirmeye çalıştım. Raporun bundan sonraki her sayfasında ankette yer alan bir soru ve bu soruya ankete katılan yazılımcıların verdiği cevaplar yer almaktadır.

Ankete katılıp, bu raporun oluşmasında emeği geçen yazılımcılara teşekkür ederim.

Özcan Acar
31.12.2012

  Yazılımcı Raporu 2012 (1,5 MiB, 9.969 yükleme)

Neden Fonksiyonel Programlamayı Öğrenmek Zorundayız

Daha dün gibi hatırlıyorum: Windows 95’in sahip olduğu işletim sistemi çekirdeğini (kernel) taskmanageri üzerinden şutlayabiliyordunuz. Akabinde tüm sistem çalışmaz hale geliyordu. Bu konularla ilgisi olmayanları kendine hayran bırakmak için fena bir yöntem değildi.

Bu bahsettiğim bilgisayarlar birkaç MB hafızası olan, tek bir işletim birimine (CPU) sahip, bir düğmesine basıldığında işletim biriminin çalışma hızını ikiye ya da üçe katlayan, bugünkü perspektiften bakıldığında taş devrinden kalma bilgisayarlardı. Geliştirilen uygulamalar da bu bilgisayarları limon gibi sıkıp, son hafıza hücresine ve işletim birimi döngüsüne (CPU cycle) kadar kullanmaya çalışırlar, ama kaynak yetersizliğinden dolayı bunda pek başarılı olamazlardı. Kısaca o zamanlarda kullanımda olan donanımın geliştirilen uygulamalar için yetersiz olduğunu söyleyebiliriz. Uygulamalar bir sonraki işletim birimi jenerasyonu ve daha fazla hafıza alanı ile hızlanır, bu donanımlarda geliştirilen uygulamalar aynı performansı göstermek için bir sonraki donanım jenerasyonunu beklemek zorunda kalırlardı.

Yazılımın hep böyle donanımı köşeye sıkıştırması, donanım mühendislerinin ışık hızı sınırlarına dayandıktan sonra, işletim birimlerinin hızını alıştıkları gibi artıramayacaklarını anlamaları ve çok çekirdekli donanım mimarisine yönelmelerine kadar devam etti. Bu noktaya gelene kadar yazılım mühendisleri donanım mühendislerine takılarak, “biz birden fazla işletim birimi varmış gibi programlarımızı yazarız, aynı işletim birimini paylaşarak çalışırlar ve en azından geliştirdiğimiz uygulamalar kullanıcıya birden fazla işletim birimi varmış gibi numara yaparlar” söylemleri ile yetindiler. Doğal olarak bu tür programlama tarzına alıştılar. Birden fazla işletim birimli sistemler çıktığında semaforlar ve threadler yardımı ile geliştirdikleri uygulamaları birden fazla işletim birimi üzerinde koşturmaya devam ettiler, eski program yazma stillerinden ödün vermeden, bunun gelecekte programcı olarak var olma ya da olmamanın cevabı olacağının farkına bile varamadan. Yazılımcıların çoklu thread (multithreading) uygulamaları geliştirmekte başarılı oldukları söylenemez. Günümüzde bile birçok programcı bir Java uygulamasında iki threadin senkronizyonunda zorluk çekmektedir.

Günümüzdeki kullanımda olan modern bir bilgisayarın en az iki ya da dört çekirdeği var. Bu yazıyı 2.8 GHz hızında, iki çekirdekli bir notebook üzerinde yazıyorum. Kullandığım işletim sistemi yükü eşit bir şekilde bu çekirdeklere dağıtmaya çalışıyor. Ne kadar başarılı olduğu tartışılır. Kullandığım bazı programlar birden fazla çekirdeğin üzerinde koşacak şekilde geliştirilmemiş. Bu yüzden beklenen performansı sağlayamıyorlar. Donanım mühendislerinin bir köşeden bizi izleyip “iki çekirdeği bile doğru dürüst programlayamıyorlar, kısa bir zaman sonra binli çekirdeklerle nasıl başa çıkacaklar acaba” dediklerini duyar gibiyim.

Bir uygulamanın optimal bir şekilde birden fazla çekirdeği kullanabilmesi için, uygulama parçalarının threadler yardımı ile birden fazla çekirdek üzerinde koşturulmaları gerekir. Bu çoğu zaman veri kaybını önlemek için threadler arası senkronizyonu zorunlu kılar. Java dilinde synchronized kelimesi ile birden fazla threadin aynı kod bloğunu koşturması engellenir. Bu tür bir sekronizasyon anlaşılması zor, komplike uygulamaların oluşmasına sebep verir. Tek bir thread ile istenilen tarzda bir davranış sergileyen bir uygulama, ikinci bir thread devreye girdiğinde çok başka bir davranış biçimi sergileyebilir. Böyle bir uygulamanın bünyesinde barındırdığı hataları debugging yöntemi ile keşfetmek çok zor bir hal alabilir. Kısaca bu tür uygulamaları geliştirmek, koşturmak ve hataları gidermek çok zordur ve çok az sayıda programcı bu durumlarla baş edebilecek yeteneklere sahiptir.

Kullandığımız imperatif (Java, C/C++, Python, PHP, Javascipt) diller thread senkronizyonu problemi haricinde başka bir sorunla karşılaşmamıza neden olmaktadırlar. İmperatif dillerde yapılan işlemler hafızada yer alan verilerin değiştirilmesi üzerine kuruludur. Bunun en basit örneği aşağıda yer alan Groovy kodunda görülmektedir.

[source language=’java’]
for(i in 1..10){
println(i);
}
[/source]

Groovy örneğinde for döngüsü başlatılmadan önce i ismini taşıyan bir değişken oluşturulur. Bilgisayarın hafıyasında i değişkeninin sahip olduğu değeri tutabilmek için 32 bit (bir int) uzunluğunda bir alan kullanılır. i nin başlangıç değeri 1 olduğu için, bu hafıza alanında yer alan değer 1 (00000000 00000000 00000000 00000001) olacaktır. Birinci döngü sona erdikten sonra i ye yeni bir değer atanır. Bu değer 2 rakamıdır. Değişkenin ismi değişmemiş olsa bile sahip olduğu değer değişmiştir. Bu imperatif dillerde sıkça karşılaştığımız bir değer atama işlemidir. Daha öncede belirttiğim gibi imperatif dillerde yapılan işlemler hafızada yer alan değerlerin değiştirilmesi üzerine kuruludur. Uygulama doğrudan hafızaya erişme (sadece kendi hafıza alanına) ve orada yer alan değerleri manipüle etme yetkisine sahiptir. İşlem gören her satır uygulamanın sahip olduğu anlık durumun (state) degişmesi anlamına gelmektedir.

Eğer i global bir değişken ve for döngüsü bir hata nedeniyle sonlanmış olsaydı, i kendisine atanan en son değeri korurdu. Örneğin i değişkeninin sahip olduğu değere bağımlı olarak başka bir threadin işlem yapmak için beklediğini farz edelim. i döngü içinde istenilen değere ulaşamadığı için diğer thread belkide hayatının sonuna kadar beklemek zorunda kalabilirdi. Tabi bazı programlama teknikleri ile bu gibi durumların önüne geçmek mümkün. Lakin görüldüğü gibi imperatif dillerde uygulamanın sahip olduğu anlık durumun koşturulan her kod satırı ile değiştirilebilir olması, bu durumun geçerliliğinin (consistency) korunmasını çok zor kılmaktadır. Aynı durum OOP’de kullanılan nesneler için de geçerlidir. Nesneler sınıf değişkenleri aracılığı ile belli bir duruma (object state) sahiptirler. Sahip oldukları metotlar aracılığı ile bu durum değiştirilebilir. Herhangi bir metot bünyesinde bir hatanın oluşması, sınıf değişkenlerine geçersiz değerlerin atanmasına ve böylece nesnenin korumaya çalıştığı durumun geçersiz hale gelmesine sebep verebilir.

Şimdi on ya da yirmi sene sonrasını hayal edelim. Binlerce çekirdeği olan bir işletim birimini geliştirdiğimiz imperatif tarzı bir uygulama nasıl optimal kullanabilir? Threadleri senkronize etmeye çalışarak bunu başarmamız mümkün değildir. Bu sebepten dolayı şimdiden binlerce çekirdeği olan bir işletim birimini optimal bir şekilde nasıl programlarız sorusuna cevap aramamız gerekmektedir. Aslında bu soruyu sorarak programcı olarak nasıl bir geleceğe sahip olacağımızın cevabını arıyoruz. Programcı olarak geleceğimizin nasıl şekilleneceği bu sorunun cevabında gizli.

Bahsettiğim problemleri aşmanın ve binlerce çekirdeği olan bir sistemi programlamanın yolu, değişkenlere tekrar, tekrar değer atamamaktan geçmektedir. Değişen değer senkronizasyonu mecbur kılmaktadır. Bu mecburiyet tüm çekirdeklerin aynı anda uygulama tarafından kullanılmasının önünde büyük bir engel teşkil etmektedir. Bu mecburiyeti ortadan kaldırmak için kullandığımız veri yapılarını değiştirilemez (immutable) hale getirmemiz gerekmektedir. Bu bir değişkene bir kere bir değer atandıktan sonra, bu değerin bir daha değiştirilemez olması gerektiği anlamına gelmektedir. Bu değişken uygulama son bulana kadar sahip olduğu değeri koruyabildiği taktirde, threadler arası senkronizasyon gerekliliği ortadan kalkar. Değişmeyen bir değer için senkronizasyon gerekli değildir.

Java gibi dillerde bir değişkene sadece bir kere değer atanması ve değişkenin bu değeri koruması final kelime ile sağlanabilir. final int i = 10; şeklinde bir tanımlama, daha sonra i=11; atamasının yapılmasına izin vermeyecektir. i her zaman 10 değerine sahip olacaktır. Bunun yanı sıra konstrüktör parametreleri aracılığı ile oluşturulan ve sınıf değişkenlerine set metotları aracılığı ile sonradan atama yapılmasına izin vermeyen nesneler değiştirilemez (immutable object) türdedir. Bu nesnelerin threadler arası paylaşımı hiçbir sorun teşkil etmez. Bu gibi yapılar thread güvenlidir (thread safe), çünkü içerikleri değişikliğe uğramaz/uğrayamaz.

Binlerce çekirdeği olan bir sistemi optimal şartlarda programlamanın yolu sonradan değiştirilemeyen (immutable) veri yapılarından geçmektedir. Peki bunun fonksiyonel programlama ile ne ilgisi var? Açıklayayım.

Fonksiyonel dillerde fonksiyonların sahip oldukları bazı özellikler şöyledir:

  • Fonksiyonlar metot parametreleri aynı olduğu sürece hep aynı neticeyi geri verirler.
  • Metot parametreleri fonksiyonlara pass by value mantığı ile verilir. Bu parametreler fonksiyon tarafından değiştirilemez. Fonksiyon yaptığı işlemin değerini geri verebilmek için yeni değişkenler oluşturur.
  • Fonksiyonlar kendi bünyeleri dışındaki hiçbir veri ya da durum (state) üzerinde değişiklik yapmazlar. Bu yüzden fonksiyonların yan etkileri (side effects) yoktur. Aynı fonksiyon durmadan koşturulsa bile hiç bir durum değişikliği olmaz.
  • Safkan fonksiyonel dillerde bir değişkene bir değer atandığı zaman, bu değer program son bulana kadar değişmez. Bu metot bünyesinde tanımlanan metot değişkenleri için de geçerlidir. Bu sebepten dolayı fonksiyonel dillerde for döngüsü içinde i değişkenine yeni bir değer atamak mümkün değildir. Değer atanmış bir değişkenin değeri değiştirilemeyeceği için yukarıda yer alan Groovy örneğini birebir fonksiyonel bir dilde yazmak mümkün değildir. Bunu gerçekleştirmek için fonksiyonel dillerde rekursiyon (recursive programming) kullanılır.
  • Bir fonksiyon geri verdiği değer ile birebir yer değiştirebilir. Bunun ne anlama geldiğini aşağıdaki Clojure örneğinde açıklamaya çalışacağım.

[source language=’java’]
(+ 1 1)
[/source]

Yukarıda yer alan Clojure örneğinde 1+1 işlemi yapılmaktadır. + burada kullanılan fonksiyonun kendisi 1 ve 1 bu fonksiyona gönderilen parametrelerdir. Parantezler kullanılarak fonksiyonun nerede başlayıp, kullanılan parametrelerin nerede bittiği ifade edilir.

5 + 9 / 4 * 2 işlemini gerçekleştirmek için Clojure dilinde şu şekilde bir fonksiyon yazabiliriz.

[source language=’java’]
(/ (+ 5 9 ) (* 4 2))
[/source]

Bu Clojure örneğinde 3 değişik fonksiyon kullanılmaktadır. Birinci fonksiyon / fonksiyonudur. Bu fonksiyona iki parametre verilmektedir. Birinci parametre 5+9 un neticesi olan 14 değeri, ikinci parametre 4*2’nin neticesi olan 8 değeridir. Yani yukarıda yer alan fonksiyonu şu şekilde de yazabilirdik:

[source language=’java’]
(/ 14 8)
[/source]

Görüldüğü gibi bir fonksiyon geri verdiği değer ile yer değiştirebilmektredir. Bu sadece ve sadece fonksiyonun işlem yaparken yan etki oluşturmaması ve aynı parametreler ile aynı neticeyi geri vermesi durumunda mümkündür. Eğer fonksiyon işlem yaparken durum (state) değişikliğine sebep vermiş olsaydı, yapılan durum değişikliğine göre (* 4 2) işleminde 8 değeri yerine başka bir değer geri alınabilirdi ki bu da bölme işleminin yanlış değerler kullanılarak yapılmasına sebep olurdu.

Paralel programlamanın önündeki en büyük engel kullanılan programlama dilinin hafıyaya doğrudan erişerek mevcut değişkenlerin sahip olduğu değerleri manipüle edebilmesidir. Uygulamanın her parçası hafızada yer alan değerleri herhangi bir zamanda değiştirebilir. Bu hem parallel programlamayı hem de uygulamanın anlık hangi durumda olduğunu öngörmeyi zorlaştıran bir durumdur. Değiştirilemez veri yapılarının (immutable data structures) kullanılması uygulamanın sahip olduğu anlık durumu (state) öngörülebilir hale getirmekte ve paralel programlama için gerekli altyapıyı sunmaktadır. Fonksiyonel dillerin değiştirilemez veri yapılarını temel olarak almaları, bu dillerin parallel programlamada daha avantajlı bir konumda olmalarını sağlamaktadır.

Gelecekte imperatif dillerin yanısıra fonksiyonel dilleri de sıklıkla kullanacağız. Donanımın geleceği parallelikte, yazılımcı olarak bizim geleceğimiz de bu paralelliğe nasıl hükmedeceğimizde. Bundan sonra geliştireceğimiz uygulamalar donanımın bize sağladığı her türlü kaynağı en optimal şekilde kullanacak yapıda olmalı. Bunun için yeni dönemde bizi bekleyen yeniliklere hazırlanmalıyız.

EOF (End Of Fun)
Özcan Acar

Nasıl Arkadaş Kazanır ve Diğer İnsanları Etkilersiniz

Dale Carnegie tarafından 1937 yılından yazılan How To Win Friends and Influence People (nasıl arkadaş kazanır ve diğer insanları etkilersiniz) başlıklı kitap her yazılımcının mutlaka okuması gereken ve güncelliğini günümüzde de koruyan çok değerli bir kaynak kitap.

Kitapta günlük hayatta takip edilmesi gereken bazı kurallar yer alıyor. Bunlar:

Kimseyi eleştirmeyin, yargılamayın ve şikayet etmeyin

Bir başkasını eleştirmek faydasızdır, çünkü eleştirilenin kendisini ve haklılığını savunmasını doğurur. Eleştirmek tehlikelidir, çünkü eleştirilenin onurunu incitir, kendisini kötü hissetmesini sağlar. Bir şeyleri eleştirerek, durumun daha iyileşmesini sağlamak mümkün değildir.

Taktiri hak edenlere bunu gösterin

İnsanların en önemli motivasyon kaynaklarından birisi taktir görmek ve kendini önemli hissetmektir. Büyük eserlerin, yapıtların ya da şahsiyetlerin oluşmasında en büyük rolü bu ihtiyaç oynamıştır/oynamaktadır. İnsanlar bu ihtiyaçlarını giderebilenlerin elinde hamur gibidirler. Hak ettiği için övülen ve taktir edilen şahıs bunu hiçbir zaman unutmaz.

Başkalarının içinde istek uyandırın

Bir bireyin istekleri diğer bireyleri ilgilendirmez. Her birey kendi istekleri ekseninde hayatına şekil verir. Bu sebepten dolayı insanları etkilemenin en kolay yolu onların istekleri hakkında konuşmaktır. Her bireysel hareketin temelinde bir istek yatar. İnsanları herekete geçirmek için içlerinde bu isteği uyandırmak yeterlidir.

Başkalarıyla ilgilenin

Baskalarıyla ilgilenenlere insanlar arası ilişkilerde her türlü kapı açıktır. İlgi çekmek için uğraş veren bir bireyin iki senede kazanamadığı arkadaşlıkları, başkalarıyla ilgilenen birisi iki ay içinde elde edebilir. Dost ve arkadaşlığın temelinde bu samimi ilgi yatar.

Gülümseyin

Gülümseme iyi niyetin göstergesidir. Gülümseme onu görenlerin gününü güzelleştirir. Gülümseme “size kanım kaynadı, beni mutlu ediyorsunuz, sizi gördüğüme sevindim” demektir.

Herkes için kendi isminin en hoş ve önemli kelime olduğunu unutmayın

Insanları kazanmanın en kolay yollarından birisi, isimlerini hatırlamak ve onur duymalarını sağlamaktır. İsimler insanları özelleştirir. İsimlerle birlikte gönderilen mesajlar daha başka anlam kazanirlar.

Bunlar gibi birçok tavsiye Dale Carnegie tarafından 1937 yılından yazılan How To Win Friends and Influence People (nasıl arkadaş kazanır ve diğer insanları etkilersiniz) başlıklı kitapta yer almakta. Okunulması tavsiye olunur.


EOF (End Of Fun)
Özcan Acar

Ayakta Alkışlıyorum

Geçen cumartesiyi pazara bağlayan gece, saat 00:00 civarı KurumsalJava.com, BTSoru.com, BizimAlem.com ve diğer web projelerimin üzerinde yer aldığı sunucuların erişilemez oldukları haberini aldım. Akabinde gecenin bir yarısı hizmet aldığım ISP’nin yolunu tuttum. Tam, tamına 4 senedir bir düğmesine bile basmadığım, bu kadar zaman sorunsuz çalışmış olan firewall sistemlerinin neden çalışmadıklarını incelemeye başladım. Bugüne kadar birçok DOS saldırısına karşı koymuş ve çalışmaya devam etmiş bu sistemlerin bir DOS saldırısı sonucu tıkanmış olabileceklerine ihtimal vermedim. Aslında firewall sistemlerinin işletim sistemlerini en yeni versiyona çekmem gerekiyordu. Fırsat bu fırsat dedim ve gerekli kurulum ve ayarları yaptım. Pazar sabahı saat altıya doğru tekrar evimin yolunu tuttum.

Yaptığım müdahale hiçbir şey değiştirmedi. Sunucular pazar günü öğleden sonra tekrar erişilemez oldular. Bu işte başka bir şey olmalı diye tekrar ISP’nin yolunu tuttum ve firewall sistemlerini canlı yayında yakından takip etmeye başladım. Kısa bir zaman sonra bu sistemleri tıkayan sebebin bir DOS saldırısı olduğunun farkına vardım. 80/100 m/bit boyutunda olan bir DOS saldırısı ile router ve firewall sistemlerini erişilemez hale getirmişlerdi. Firewall ve router sistemleri üzerinde DOS saldırılarının kaynağı olan network segmentlerinin (188.0.0.0/8) sunuculara erişmesini engelledim.

Aldığım bu son önlem karşı tarafı daha da kızdırmış olacak ki dünden beri 3 g/bit kapasitesinde DDOS saldırıları başlatılmış. Biraz önce sunucularımın barındığı ISP’nin administratörlerinden birisi beni arayarak, durumdan haberdar etti. ISP’nin benim yer aldığım network segmenti tamamen offline olmuş durumda.

Çok uzun zamandan beri, özellikle BizimAlem.com web platformu ile Türk hackerlerin saldırılarına mağruz kalıyorum. Bir şekilde hepsine sistemi daha güçlü hale getirerek cevap verdim. Bu gibi şeylerle muhattap olmak benden çok sinir aldı götürdü, ama bilgi olarak ta birçok şey kattı. Ama artık saldırıların boyutu o kadar değişti ki, karşı taraftaki şahıslar koca bir ISP’yi dize getirebiliyorlar. Bu sebepten dolayı bu yazının başlığında da yer aldığı gibi bu şahısları ayakta alkışlıyorum. İnsanlığa, vatana, millete o kadar çok büyük emek, fayda ve katkıları var ki, kendilere mutlaka bir onur madalyası verilmeli.

Benim internet girişimciliğinde son on yılda edindiğim tecrübeler şöyle:

  • Meyva veren ağaç taşlanıyor. İnternette göze batan bir büyüklüğe eriştiğiniz zaman, sizin tekerinize çomak sokmak isteyen birçok insan ortaya çıkacaktır. Bu insanlar istedikleri taktirde çok emek harcayarak oluşturduğunuz bir web platformunu kısa bir zamanda çalışmaz hale getirebilirler. Bunun için Rusya’dan ya da Türkiye’den birkaç hacker bulmaları yeterli. Buradan çıkardığım sonuç şu: internet girişimciliği gerçek hayattaki bir girişimden yüzlerce defa daha rizikolu. Bu hem başarıyı yakalamak için, hem de yakalanan başarıyı korumak için geçerli.
  • Günümüzün internet altyapısı, özellikle TCP/IP protokolü web platformlarını ve yapılan yatırımları korumak için yeterli değil. Bunun kısa bir zamanda değişeceğini de düşünmüyorum. İnternet girişimciliği rus ruletinden farklı bir şey değil.
  • Bazı şahıslar kişisel başarısızlık, pisilojik bozukluklar ve toplum tarafından dışlanmış ya da kabul edilmemiş olmak gibi faktörleri kompanze etmek için bahsettiğim türde internet saldırılarını gerçekleştiriyorlar. Başkalarına zarar vermekten büyük zevk alan bu şahıslara internet mazohistleri diyorum. Çok az bir mantık ve zeka ile böyle uğraşıların ne kendilerine, ne de başkalarına bir fayda getirdiğini anlamaları zor değil. Ama ne yazık ki bu yetilerden mahsunlar. Onlar karanlık odalarından bu saldırılara devam edecekler ve insanlıktan nasiplerini alamadan ebediyete intikal edecekler, bizler de ebediyete intikal edene kadar bu şahıslara karşı dik durmaya devam edeceğiz. DevOps olarak görevimiz bu.
  • Sunucuları istediğiniz kadar koruyun, onları erişilmez hale getirmek için mutlaka bir yöntem mevcuttur. Birileri sizden bilgi olarak mutlaka bir, iki adım önde olacak ve fırsatını bulduğu anda sunucuları kendi kontrolüne geçirmeye ya da erişilemez olmalarını sağlamaya çalışacaktır. Bu internetin değişmez bir kanunu. %100 korunma imkansız.
  • Bu tür saldırıların kimin marifeti olduğunu öğrenmeniz imkansız. Bu sebepten dolayı yasal yoldan hakkınızı aramanız mümkün değil.

  • Bu tür saldırılar bir yazılımcıyı bir DevOps (development/operations; hem program yazan, hem uygulamayı sunucularda işleten anlamında) haline getiriyor.

Neden böyle bir yazı yazdım? Saldırıları yapanlar haberdar olsunlar ve saldırıları durdursunlar diye mi? Hayır, böyle bir amacım yok. Kimin, hangi sebepten dolayı böyle bir şeyi yaptığı beni pek ilgilendirmiyor. Ben daha ziyada edindiğim tecrüleri, konuyla ilgilenen okurlarımla paylaşmak istedim. Eğer internet girişimci iseniz ya da internet girişimcisi olmak istiyorsanız, sizi bekleyen bazı sürprizler var. Hazırlıklı olmanızda fayda var.

EOF (End Of Fun)
Özcan Acar

Copy/Paste Programcı

Internetin bu kadar büyümesi ve özellikle Google gibi arama motorlarının günlük iş hayatımızın bir parçası haline gelmesi biz programcılar için ne kadar hayırlı oldu, bilemiyorum. Pek te hayırlı olmadığı kanısındayım. Açıklamaya çalışayım.

Çalıştığım projede bir çalışma arkadaşımın masasında algoritmalarla ilgili kalınca bir kitap gördüm. Havadan, sudan konuşurken kendisi böyle kitapların artık gereksiz olduğunu, çünkü internette istediğin algoritmayı bulup, kullanabildigini söyledi. Doğru, haklıydı.

Bugünlerde Pratik Spring Core 3 isminde yeni kitabım üzerinde çalışmalarımı sürdürüyorum. Spring ile XML bazlı deklaratif transaksiyon yönetimi konfigürasyonu nasıl yapılır diye internette araştırma yaparken, birkaç klasik blog sayfasına rastladım. Bu klasik blog yazılarını tanırsınız. Basit bir örnek üzerinde belli bir konfigürasyonun nasıl yapıldığını gösterirler. Bu örnekleri copy/paste yaparak programcının kendi uygulamasına eklemesi zor değildir. Zamanında az yapmadık. Copy/paste işlemi esnasında insan keşfettiği örneğin altındaki konseptlerin ne olduğunu sorgulamıyor. Programcı için önemli olan bir şeyleri çalışır hale getirebilmek. Ve bunu başardıktan sonra, “ya, bunu çalışır hale getirdim ama, bu işin temelindeki konseptler nelerdir” şeklinde bir sonuca varmıyor ya da varamıyor. İşte internet üzerinden bilgiye bu kadar hızlı, sorgusuz ve sualsiz erişmenin getirdiği hayırsızlıkta bu noktadan itibaren başlıyor. Programcı bir bilgiyi edindi ve kullandı. Ama o bilginin neyi temsil ettiğini, yani temelinde neler olduğunu bilmiyor. Spring ile XML bazlı deklaratif transaksiyon yönetimi konfigürasyonu örneğinde 3 satırlık copy/paste edilen XML konfigürasyonunun altında AOP (Aspect Oriented Programming) ve Proxy tasarım şablonu gibi konseptler var. İki satırlık konfigürasyonu kopyaladım, ama temelinde yatan bu bilgileri kopyalayamadım. Bunlar internette kalmaya devam etti. Benim kopyaladığım cansız, iki satırlık kod parçası.

Kod örneğiyle, kodun temelindeki konseptlerin zahmetsiz bir şekilde beyne nasıl kopyalandığını Matrix filmede gördük. Neo anında Karate-Kid olmuştu. Bizim böyle bir imkanımız yok. Böyle bir şeyin gelecekte mümkün olacagını da düşünmüyorum. Geriye kalan, kaynağını bulup, copy/paste yaptığımız bilgilerin temelinde yatan konseptleri ögrenmek ve uygulamak. O zaman hayırsız olarak tabir ettiğim işlemi hayırlı bir işleme dönüştürebiliriz.

Copy/paste zihinlere o kadar yerleşmiş ki, bilgiye sahip olmanın değil de, bilgiye nasıl ulaşabileceğini bilmenin daha önemli olduğunu savunanlar var. Bu artık copy/paste filozofisinin mükemmelleştirilerek, getirildiği en son noktadır, yani bu akımın en tepesindeki noktadır. Bu filozofiye sahip olanların, iş görüşmelerinde bu tür ifadelerde bulunmamalarını tavsiye ediyorum, çünkü iş verenin en sevmediği ve iş görüşmesini anında sonlandırabileceği durumların başında, iş görüşmesi yaptığı şahsın “ufak bir internet araştırması ile bu sorunu çözebilirim” tarzı söylemlerde bulunmasıdır. Böyle bir şey söyleyen şahıs aslında “ben bu bilgiye sahip değilim, başkaları sahip, ama bir bakayım, bakalım, bir yerlerden bulabilir miyim” demektedir. Böyle bir şey söyleyen bir programcıyı siz olsanız işe alır mıydınız?

İyi bir programcı olabilmek için iyi bir temele sahip olmak gerekir. Bu temel edinilmiş ve zaman içinde edinilen bilgiden oluşur. Programcı tüm yeteneklerini bu temel üzerine inşa eder. Zaman zaman internetten bir şeyleri copy/paste etmek suç ya da günah değildir. Bu hepimizin yaptığı bir şeydir. Lakin programcı copy/paste yaptıktan sonra, copy/paste yaptığı kod parçasının temelinde yatan bilgiyi sahip olduğu temele eklemekle yükümlüdür. Aksi taktirde bu bakkaldan bir sakız alıp, parasını ödememek gibi bir şey olur. Copy/paste yapılan şeyin bedeli ödenmelidir. Copy/paste edilen kodun üzerinde fiyat etiketi olmadığı için beleş sananlar vardır. Hayır, beleş değildir. Bedeli ödenmeden kullanılan bilgi, temeli sağlam olmayan bir binanın en ufak bir rüzgar esintisinde sallanması misali programcıya zarar verir.

Copy/paste yapalm, ama bedelini ödeyerek…

EOF (End Of Fun)
Özcan Acar

Test Edebilme Uğruna Her Şey Mübahtır!

Geçenlerde yine tartışması yapılıyor: private olan metotları nasıl test ederiz? Benim cevabım: “edemeyiz!” Karşıdan gelen cevap: “dediğim gibi, her şeyi test etmek mümkün değil demek ki!“. Benim cevabım: “her şeyi test etmek mümkün, private’i protected yaparsın, olur, biter.” Karşı tarafın cevabı: “kardeşim ortada OOP diye bir şey var, kafana göre nasıl öyle private bir metodu proteted yaparsın?“. Yaparım canım kardeşim. OOP’yi filan takmam! Protected‘de yaparım, public‘de. Bir sınıfı test edebilmek için her türlü yöntemi kullanırım, gözünün yaşına bakmam. Bu uğurda her şey mübahtır.

Bu bazıları için çok radikal bir yaklaşım tarzı gibi görünebilir. Ama uygulama çalışırken bir sebepten dolayı patladığı zaman kimse gelip size, bu sınıfı neden OOP’ye uygun tasarlamadınız diye sormaz. Bu sınıf neden patladı, sizin testleriniz yok mu diye sorar! O zaman da “bu metot private idi, o yüzden test yazamadım” mi diyeceksiniz? Pek ikna edici değil, değil mi?

Bir uygulama geliştirken bir kod biriminin test edilebilirliğinin önündeki engel OOP prensipleri olmamalıdır. Eğer öyle ise, OOP prensipleri yanlış uygulanmış demektir. OOP kod geliştirmek için kullanılan bir araçtır. private yerine göre kullanılabilecek bir erişim mekanizmasıdır. Lakin private olan bir metot benim için yoktur, yani test edilmesi mümkün değildir. Benim için test edilemeyen kod birimi olamayacağı için, private ile tanımlanmış metotları yok sayarım. Test edilemeyen bir metodun başına her türlü iş gelebilir. Benim bu tür metotları görünce ilk yaptığım şey, metodu hemen protected yapmak ve o metodu izole bir şekilde test eden bir birim testi yazmak olur. Protected yetmedi ise public yaparım. Nihai amaç metodu bir şekilde test edebilmektir.

Ne test edilir, ne test edilmez, nasıl test edilir tartışmalarının sonu gelmez ne yazık ki. Geçenlerde yine kocaman, ne yedüğü belli olmayan bir sınıfa yeni bir özellik eklemem istendi. Eğer gerekli kodu o sınıfa direk ekleseydim, yeni eklediğim kod birimini test etmem çok zor olacaktı, bunu biliyordum. Sınıfın tümünü test edecek bir birim testi oluşturmak için vaktim yoktu. Bende bunun yerine yeni bir static iç sınıf oluşturup, kodu bu sınıfın bir metodu olarak geliştirdim ve bir birim testi ile test ettim. Testin başarılı olduğunu gördükten sonra ne yedüğü belirsiz diye tabir ettiğim sınıfın gerekli metoduna oluşturduğum yeni sınıfın bir nesnesini yerleştirerek, static sınıfın metodunu orada koşturdum. Böylece ne yedüğü belirsiz sınıf dolaylı bir şekilde yeni oluşturduğum kod birimine sahip oldu. Doğal olarak gelen ilk soru şu oldu: “neden static bir iç sınıf oluşturdun ki? Orada bu işi görecek bir metot vardı, o metoda kendi kodunu ekleyebilirdin“. Eklerdim, eklemesine, lakin bu sınıfa eklediğim kodu nasıl test edebilirdim? Edemezdim. Sınıf için daha önce hiç birim testi yazılmamıştı. Sınıfa eklediğim kod birimini test edebilmek için tüm uygulamayı ayağa kaldırıp, benim eklediğim kod birimi çalışıyor mu diye otomatize edilemeyecek türden bir test yapmam gerekirdi. Yok efendim. bu tür yöntemler sınıf enflasyonuna sebep oluyormuş. Olursa, olsun, sorun nedir? Önemli olan benim yeni kod birimini izole bir şekilde test etmemdi.

OOP, tasarım şablonları ya da tasarım prensipleri sadece test edilebilirliğin emrinde çalışabilecek erlerdir, tersi değil! Bu saydığım araç, gereçlerin hepsinin efendisi test edilebilirlik özelliğidir. Bunların arkasına saklanıp, bu kod birimi test edilemez diyen yazılımcı kendisine ve müşterisine ihanet içinde olur.

EOF (End Of Fun)
Özcan Acar

Deneme Yanılmanın Bedeli

Yazılım yaparken en büyük zaman kaybının nedeni, kodu değiştirip, derleyip, çalışır hale getirdikten sonra değişikliğin sonucunu test etmektir. Kodu değiştir/derle/çalıştır/dene süreci otuz saniyeden beş dakikaya kadar sürebilir. Günde bunu on sefer yaptığınızda bir saatlik bir zamanı boşa harcamış olursunuz. Bu sebepten dolayıdır ki EJB2 ve benzeri teknolojilerin yerine Spring gibi daha hafif yazılım yapmayı sağlayan çatılar (framework) oluşmuştur.

Çoğu programcı yılmadan kodu değiştir/derle/çalıştır/dene döngüsünde programlamaya devam ediyor. Büyük bir inatla, akıl almaz derecede komplike olan algoritmaları deneme, yanılma usulü ile geliştirmeye ya da değiştirmeye çalışanlar var. Neymiş efendim, bir sonraki döngüde çalışacakmış… Murphy’nin kuralları gereği yapılan değişikliğin beklenen neticeyi getirmeme ihtimali çok yüksek. Ve böylece programcı hiç farkına bile varmadan dönme dolap içinde dönüp, duran bir fare misali hayatını devam ettirir….

Aslında böyle durumlarda beyinde tehlike çanları çalmaya başlayıp, programcının içinde bulunduğu kısır döngüyü aşması için gerekli rutinlerin çalışması gerekir. Mesela bu rutinlerden bir tanesi “hemen kodu test eden bir birim testi yaz” olabilir. Bir birim testi bahsi geçen kod birimini izole edilmiş halde çok hızlı bir şekilde test etmek için kullanılabilir. Yapılan değişikliğin neticesini görmek bir saniye bile sürmeyecektir. Gerekli değişiklikler yapıldıktan sonra ayrıca bonus olarak bir birim testine sahip olunur. Daha sonra yapılması gereken değişiklikler birim testi sayesinde çocuk oyuncağı haline gelir. Zaman ayrılıp, mutlaka böyle bir yatırım yapılmalıdır, aksi taktirde deneme, yanılma tarzı programlamanın bedeli çok daha ağır olacaktır. Sözüm tabi verimliliğim düştü derdinde olmayanlara değil.

“Hemen test yaz” vari bir rutinin devreye girebilmesi için iki şeye ihtiyaç duyulmaktadır:

  • Böyle bir rutine sahip olmak.
  • Rutini zamanı gelince otomatik olarak tetiklemek.

Bu rutini çalıştırabilmek için bu rutine sahip olmak gerekiyor. Böyle bir rutine nasıl sahip olunabileceğine Kod Kata ve Pratik Yapmanın Önemi başlıklı yazımda değinmeye çalıştım. Bu işin sırrı devamlı pratik yapmaktan geçiyor. Pratik sahibi olan bir programcının aklına ilk gelen şey “ya ben neden bir birim testi yazmıyorum da, burada taklalar atıyorum” olur. Basit gibi görünen bu beyin performansını sağlayabilmek için beyni bu yönde eğitmek gerekiyor. Bunun yolu da kod katalarından geçiyor. KodKata.com‘a bir göz atmanızı tavsiye ederim.

Deneme, yanılma tarzı programlama hem insanı yorar, hem usandırır, hem de bir zaman sonra bıkkınlık verir. Ayrıca bu tarz programlamanın yazılım mühendisliği ile yakından, uzaktan ilgisi yoktur. Mühendis olmak demek yol, yordam bilmek demektir, metotlu, yöntemli çalışmak demektir. Çaylak gibi bilgisayar başına geçip, deneme, yanılma tarzı programlama yapan yazılımcıya gülerler. Profesyonel programcı hemen çekmecesinden ihtiyaç duyduğu aracı, yani birim testi yazma yetisi, çıkarır ve sorunu en kısa sürede daha önce etkinliliği milyarlarca defa kanıtlanmış bir yöntemi kullanarak çözer. Yol, yordam bilmek budur. Profesyonel yazılımcıya yakışan budur.

EOF (End Of Fun)
Özcan Acar

Uzaktan Eşli Programlama

Eşli programlama yapmak için illa iki programcının aynı mekanda olması gerekmiyor. Eclipse kullanıyorsanız Saros pluginini kurarak, uzak bir bilgisayardaki bir şahıs ile eşli programlama yapabilirsiniz.

Uzaktan eşli programlama için neler gerekli?

Eclipse >> Help >> Install new Software menüsünden http://dpp.sourceforge.net/update Saros update sayfasını kullanarak gerekli plugini kurabilirsiniz.

Kurulumun nasıl yapıldığı Saros kurulum sayfasında yer almaktadır.

Kurulum işlemi tamamlandıktan ve Eclipse kapatılıp, yeniden açıldıktan sonra yukarıda yer alan login paneli görünecektir. İki programcının beraber aynı proje üzerinde çalışabilmeleri için aynı sunucuya bağlantı kurmuş olmaları gerekmektedir. Saros sunucu olarak bir Jabber sunucusu kullanıyor. Yeni bir hesap oluşturduktan sonra sunucuya bağlanabilirsiniz.

Eşli programlama yapmak istediğiniz şahsın Saros hesabını edinmeniz ve aşağıda yer aldığı gibi Saros paneli üzerinden Buddy listenize eklemeniz gerekiyor.

Buddy ekleme işlemi tamamlandıktan sonra eğer Buddyniz online ise, herhangi bir Eclipse projesini karşı taraf ile paylaşıp, eşli programlamaya başlayabilirsiniz. Proje üzerinde yaptığınız her değişiklik anında karşı tarafa yansıyacaktır.

Ben bu altyapıyı genelde uzakta bir bilgisayar kullanan bir programcı ile beraber kata yapmak için kullanıyorum. Kata seansında iletişimi kolaylaştırmak için Skype kullanılabilir.

Benimle kata yapmak isterseniz koordinatlarım şöyle:

Saros hesabım: ozcanacar@saros-con.imp.fu-berlin.de
Skype hesabım: oezcanacar

Bana bir e-posta gönderin ve hangi katayı benimle birlikte eşli programlama yöntemi ile yapmak istediğinizi bildirin. Birlikte bir zaman dilimi bulmaya ve katayı yapmaya çalışalım.

EOF (End Of Fun)
Özcan Acar

Veresiye Satan Yazılımcı

Editörü açtınız, public class yazarak yeni bir sınıf oluşturdunuz. Bu sınıfa yeni bir metot eklediniz. Başka bir şey yapan yeni bir metot daha eklediniz. Sınıf yavaş yavaş şismeye başladı. Birkaç refactoring yaptınız. Buradan yeni bir sınıf dünyaya gözlerini açtı. Bir sınıf, bir sınıf daha derken sınıf sayısı onlara ulaştı. Her sınıfın metot küfesi iyice ağırlaşmaya başladı. Göz açıp, kapayana kadar birkaç bin satır kod oluştu. Program istediğiniz şekilde çalışıyor sanırım. Yaptığınız işten memnunsunuz, ama içinizden bir ses bir şeylerin doğru gitmediğini söylüyor. Eksik olan ne? Testler!

Yazılımcı neden test yazmaz? Sıralayalım:

  • Uygulamayı test etme konseptlerinden bihaberdir.
  • Test etmeyi gerekli ve işinin bir parçası olarak görmez.
  • Test etmeyi angarya ya da zaman kaybı olarak görür.
  • Geliştirdiği uygulamanın test edilemez olduğunu düşünür.
  • Test etmek için zamanı yoktur.
  • Daha sonra test yazarım diyerek kendini avutur.
  • Testlerin yazılımcı olmayan şahıslar tarafından yazılmasını sağlamak için lobi çalışması yapar.
  • Testlerin devamlı bakıma ihtiyacı olduğunu ve bu yüzden verimli olmanın önünde engel olduklarını düşünür.

Bir yazılımcının görevi nedir? Sıralayalım:

  • Altına tereddüt etmeden ismini yazıp, imzalayacağı, çalışır, hatasız ve kaliteli bir sürüm ortaya koymak.
  • ve daha birçok başka şey.

Yazılımcı test yazmadığı zaman ne olur? Sıralayalım:

  • Devamlı oluşan hatalarla boğuşur.
  • Kodu yeniden yapılandırma cesaretine hiçbir zaman sahip olamaz.
  • Yeni müşteri gereksinimlerini kodlamakta zorlanır, çünkü yeniden yapılandırılamayan kodun değiştirilmesi güçtür.
  • Sürüm çıkardıktan sonra birkaç gece uyuyamaz.
  • Hataları gidermek için fazla mesai yapmak zorunda kalır.
  • Uygulamanın her yeni sürümü ile hata sayısı çoğalır, kod kalitesi düşer.
  • Yaptığı işten zevk almamaya başlar.
  • İşini tam olarak yapmadığını bildiği için vicdan azabı çeker.

Veresiye satan tüccar ile peşin satan tüccarın hikayesini bilirsiniz. Veresiye satanın sonu malumdur. İşi başından sıkı tutmadığı için batma aşamasına gelir. Test yazmayan programcının da durumu aynıdır. Projenin geleceğini veresiye dağıtır.

Siz veresiye mi satıyorsunuz, peşin mi?

EOF (End Of Fun)
Özcan Acar

Uzman ve Usta Yazılımcı Arasındaki Fark

Fanatik futbol severleri bilirsiniz. Takımları için yapmayacakları yoktur. Bu fanatiklik başka insanlara zarar vermeye kadar varabilir. Yazılımda da durum farklı değildir. Tek fark bu fanatikliğin insana zarar verecek seviyede olmamasıdır.

Çok duymuşsunuzdur Java dili şöyle, Java dili böyle, diğer dillerden üstündür… diye. Neden bazı yazılımcıların böyle fanatizm olarak görülebilecek bir ilgi ve alaka ile bazı bilişim öğelerine bağlandıklarını biliyor musunuz? Bu yazımda bu soruya cevap vermeye çalışacağım.

Bilişim ya da yazılımda fanatik olanlar savundukları konu hakkında uzman ya da uzman olduklarını düşünen şahıslardır. Yıllar süren çalışmalar sonunda örneğin bir programlama diline uzman seviyesinde hakimdirler. Sahip oldukları fanatizm ile savundukları konu hakkında yıllar süren çalışmalar ardından yoğun bilgi, tecrübe ve beceri sahibi olmuşlardır. Kısacası bu konuda uzmanlaşmışlardır. Fanatik bir biçimde kendilerini ifade etmeye çalışmalarının altında gizli olan iki şey vardır: Birincisi sahip oldukları bilgi, tecrübe ve beceriyi ortaya koymak istemeleri, ikincisi farkında olmadan yeniliklere açık olmadıklarını ifade etmeleri.

Bir konuda uzmanlık ne yazık ki çok uzun sürebilecek bir bağımlılığı beraberinde getirebilir. Bu insanda zaman içinde sahiplenme hissi doğurur. Çok emek harcayarak bir yerlere geldiğini düşünen şahıs için savunduğu konu kutsallaşır. Bu durum savunma ve koruma güdülerini tetikler. Buradan da tanıdığımız ve hoşumuza gitmeyen verimsiz tartışmalar doğar. Belli bir programlama dilinin fanatikçe savunulduğu tartışmaların kimseye bir şey katmayacağını çok iyi biliriz. Ama bu fanatizm yine de bir son bulmaz. Devam eder gider, çünkü yazılımcı uzman olmaya devam eder, çünkü usta olmanın ne olduğunu kavrayamamıştır.

Tipik bir uzmanın bir çalışma ömrü boyunca aynı programlama dilini kullandığını görmek mümkündür. Uzmanlık sıfatı ne kadar olumlu görünsede, bahsettigim sebeplerden dolayı sakınılması gereken bir durumdur. Bir uzman yazılımcı at gözlüğü takmışcasına hayatın içinden geçer, gider, kişisel gelişim için gerekli nimetleri edinemeden. Kendisini bir konuya adadığı için, bu konunun modası geçtiğinde ortada kalıverir. Hakim olduğu konu haricinde yeni bir şeyler öğrenme yetilerini geliştirmeği için iş hayatının son bulması teklikesi ile karşı karşıya kalabilir. Buraya kadar yazdıklarımdan bir konuda uzman olmaya sıcak bakmadığımı düşünebilirsiniz. Bir değil, birden fazla konuda uzmanlığı tercih ederim. Bunun yazılımdaki karşılığı uzman değil, usta yazılımcı olmaktır.

Usta bir yazılımcının öz geçmişine göz attığınızda, onlarca programlama dilini kullandığını görürsünüz. Hepsinde uzman olup, olmadığı tartışılır. Lakin bu onun uzmana nazaran değişikliklerle daha iyi yaşayabildiği anlamına gelmektedir. Zaman ve mekan neyi gerektiriyorsa, o konuyu seçerek, konu üzerinde çalşır ve zamanla uzmanlaşır. Geniş bir perspektife sahip olmasının sebebi buradan kaynaklanmaktadır. Çok değişik dil, teknoloji ve platformlarla çalışmak daima onun ufkunu genişletir. Bu onun günlük işlerine olumlu olarak yansır. Bu ona pragmatik olmayı öğretir. Bu ona teknoloji fanatiği olmamayı öğretir. Uzman ve usta yazılımcı arasındaki fark budur!

EOF (End Of Fun)
Özcan Acar

İzci kuralı

Her izcinin uyduğu bir kural vardır:

“Kamp yaptığın yeri bulduğundan daha iyi bir şekilde bırak!”

Yazılımcı olarak bu kuralı uygulamak istediğimiz taktirde, mevcut yazılım standartlarına uymayan kod birimlerini tereddüt etmeden yeniden yapılandırarak, uygulamanın bakılabilirliğini ve geliştirilebilirliğini artırmamız gerekir.

Usta bir yazılımcının geride bıraktığı kodun kalitesi, işe başladığında bulduğu kodun kalitesinden her zaman daha iyidir.

EOF (End Of Fun)
Özcan Acar