Java Günlüğüm http://www.javaturk.org Yazılım, Java, BT, azıcık felsefe, biraz mizah... Mon, 21 Aug 2017 18:45:58 +0000 tr-TR hourly 1 https://wordpress.org/?v=4.7.5 https://i0.wp.com/www.javaturk.org/wp-content/uploads/2015/01/java-jar-icon-54c11079v1_site_icon.png?fit=32%2C32 Java Günlüğüm http://www.javaturk.org 32 32 83392200 Java Kurulumu ve İlk Ayarları – II: Java Kurulumu ve İlk Ayarlar http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-ii-java-kurulumu-ve-ilk-ayarlar/ http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-ii-java-kurulumu-ve-ilk-ayarlar/#respond Mon, 21 Aug 2017 08:05:12 +0000 http://www.javaturk.org/?p=6817 Bir önceki yazımızda platformlardan ve Java ile ilişkilerinden bahsetmiştik. Bu yazıda Java kurulumu ve yapılması gereken ayarları ele alacağız.

Java Kurulumunu İndirmek

Oracle JDK

Bir makinaya JDK ya da JRE kurmak istiyorsak, aşağıdaki Oracle’ın Java resmi sayfasına gidip, oradaki platformunuza uygun kurulumu indirmeniz gereklidir.

http://www.oracle.com/technetwork/java/index.html

Gerçi ben hala bu sayfayı ezberleyemedim ya da daha doğrusu zihnim onu henüz http://java.sun.com yerine koyamadı ve ben hala bu adresi kullanıyorum  😀

Java’nın resmi sayfasında, sağ üst köşede bulunan “Top Downloads”ın altındaki “Java SE” linkini tıklayarak “Java SE Downloads” sayfasına gidilir. Bu sayfada en yukarıda Java’nın en son sürümünün JDK, JRE ve Server JRE kurulumlarını indirmek için gerekli düğmeler vardır. Biz geliştirici olarak JDK’yı indireceğiz.

Gelinen sayfada JDK kurulumları için indirme linklerinin bir listesi vardır:

  • Solaris Unix
  • Linux (rpm ve tar olarak)
  • Mac OS ve Windows

Lisans sözleşmesini kabul edip, platformunuza uyan linki tıklayarak JDK’yı makinanıza indirebilirsiniz.

Eğer bu sayfada platformunuza uyan bir JDK kurulumu yok ise, platformunuzun üreticisi olan şirketin sağladığı JDK’i bulup indirmeniz gereklidir. Örneğin IBM’in AIX ya da z/OS platformları için JDK kurulumları IBM’in ilgili sayfalarında bulunabilir:

https://www.ibm.com/developerworks/java/jdk/

Open JDK

Open JDK pek çok Linux paketi için açık kaynak kodlu bir JDK’dır ve aşağıdaki linkten ulaşılabilinir: 

http://openjdk.java.net/

2006’da Sun’ın bağışladığı kod tabanıyla (code base) ile oluşturulmuş bir JDK gerçekleştirmesidir. Oracle ve pek çok farklı şirketin JDK’sı, Open JDK üzerine kurulmuştur.  Linux için Oracle’ın JDK’sı yanında Open JDK da kurulabilir.

JDK’yı Kurmak

Windows ve Mac OS

Windows ve Mac OS için indirilen JDK, varsayılan ayarlarla, “next/continue” vb. tıklamalarla, kurulur.

Eğer JDK’in sürümü 1.8.0.144 ise JDK’in patikası Windows için

C:\Program Files\Java\jdk1.8.0_144

  • Mac OS için

/Library/Java/JavaVirtualMachines/jdk1.8.0_144

  olacaktır.

Linux

Ubuntu için Open JDK kurmak için terminalde şu komutu girmeniz yeterlidir:

sudo apt-get install openjdk-8-jdk

Ubuntu JDK’yı /usr/lib/jvm patikasına kurar. Dolayısıyla JDK’in tam patikası şöyle olur:

/usr/lib/jvm/java-1.8.0-openjdk-amd64

Ubuntu’da kurulumla javac ve java komutları /usr/bin/javac ve /usr/bin/java ile eşleştirilmiştir. Dolayısıyla “javac -version” ve “java -version” çalışır haldedir.

İsterseniz Ubuntu’ya Oracle JDK’yı da kurabilirsiniz. Bunun için Oracle’ın JDK indirme listesinin bulunduğu yerden örneğin jdk-8u144-linux-x64.tar.gz dosyasını indirip açtıktan sonra oluşan jdk1.8.0_144 dosyasını istediğiniz yere, mesela /usr/local/java dizinine, koyabilirsiniz.

JDK’nın Dizin yapısı

Platformdan bağımsız olarak JDK kurulumundan sonra JDK patikasında şu dosyalar ve dizinlerin olduğu görülebilir:

  • src.zip: Java kütüphanelerinin kaynak kodudur.
  • bin: javac gibi çalıştırılabilir (executable) komutlar vardır.
  • lib: İçinde bazı jar (Java’nın arşiv formatı) dosyaları vardır.
    • jre: İçinde JRE vardır. Burada da şu iki dizin bulunur:
      • bin: java gibi çalıştırılabilir (executable) komutlar vardır.
      • lib: rt.jar gibi Java kütüphanelerinin ve diğer bazı araçların arşiv dosyaları ve diğerleri vardır.

 

Java Ayarları

JDK kurulduğunda yapılacak en temel iki şey, JAVA_HOME ortam değişkenini (environment variable) tanımlamak ve PATH ortam değişkenine gerekli eklemeyi yapmaktır.

JAVA_HOME

JDK’in patikasına JAVA_HOME denir ve bu ayarla JDK kurulumunun yeri ifade edilir. Bazı Java yazılımları, örneğin Tomcat, JAVA_HOME ile Java’ya ulaşırlar. Dolayısıyla JAVA_HOME bir ortam değişkeni olarak tanımlanmazsa ileride problem olabilir.

Windows

JAVA_HOME Windows’da Ortam Değişkenleri (Environmental Variables) ile tanımlanır. Örneğin Gelişmiş Sistem Ayarları (Advanced System Settings) => Ortam Değişkenleri (Environment Variables) sayfasında Yeni (New) tıklanarak açılan pencerede değişken adı olarak JAVA_HOME, değişken değeri olarak da JDK’nın patikası, örneğin “C:\Program Files\Java\jdk1.8.0_144” girilir. Bu değişikliği uyguladıktan sonra açılan komut satırında “javac -version” ve “java -version” komutları doğru sonucu verecektir. Komut satırı zaten açık ise, değişikliğin etkisini görmek için kapatılıp yenisinin açılması gereklidir. Ayrıca komut satırında “set JAVA_HOME” komutu da size JAVA_HOME değişkeninin değerini verecektir.

Mac OS

Mac OS’da JAVA_HOME için kullanıcı dizinindeki “.bash_profile” dosyasında aşağıdaki gibi tanım yapılması gereklidir:

export JAVA_HOME = /Library/Java/JavaVirtualMachines/jdk1.8.0_144/Contents/Home

JDK patikası için, “/Contents/Home” eklemeyi unutmayın.

Bu değişikliği uyguladıktan sonra açılan terminalde “javac -version” ve “java -version” komutları doğru sonucu verecektir. Terminal zaten açık ise, değişikliğin etkisi için kapatılıp yenisinin açılması ya da terminalde “source ~/.bash_profile” çalıştırılması gereklidir. Benzer şekilde terminalde “echo $JAVA_HOME” komutu da size JAVA_HOME değişkeninin değerini verecektir.

Mac OS’da “/usr/bin/javac” ve “/usr/bin/java” komutları “javac” ve “java” komutlarıyla eşleştirilmiştir. Benzer şekilde “/usr/libexec/java_home” komutu da JAVA_HOME değişkeniyle eşleştirilmiştir. Ayrıca “/usr/libexec/java_home -V” komutu size sistemde kurulu tüm JDK ve JRE’leri listeler. /usr/libexec/java_home -X” komutu da sistemde kurulu X sürümlü JDK ve JRE’leri listeler.

echo export “JAVA_HOME=\$(/usr/libexec/java_home -v X) >> ~/.bash_profile” komutu da X sürümlü JDK kurulumunun patikasını JAVA_HOME olarak atayacaktır:

echo export “JAVA_HOME=\$(/usr/libexec/java_home -v 1.8) >> ~/.bash_profile

Linux

Ubuntu’da JAVA_HOME değişkenini tanımlamak için /etc/profile dosyasına aşağıdaki satırı yazmanız gereklidir:

export JAVA_HOME=“/usr/lib/jvm/java-1.8.0-openjdk-amd64”

Terminal zaten açık ise, değişikliğin etkisi için kapatılıp yenisinin açılması ya da terminalde /etc dizininkeyken “source profile” çalıştırılması gereklidir.

PATH

Yapılacak diğer şey ise işletim sistemlerinde çalıştırılabilir program ve komutlara ulaşımı kolaylaştırmak amacıya tanımlanmış PATH ortam değişkenine JDK’in bin dizinini eklemektir. Aksi taktirde JDK’in bin dizinindeki çalıştırılabilir komutlara ulaşılamayacaktır. Örneğin Windows ve Mac OS’da JDK sürümü için kullanılan “javac -version” da, JRE sürümü için kullanılan “java -version” de “komut bulunamadı” hatası verecektir. Dolayısıyla JDK’in bin dizini PATH ortam değişkenine eklenmelidir ki javac vb. komutlara komut satırından ulaşılabilsin.

Windows

Windows’da Gelişmiş Sistem Ayarları (Advanced System Settings) => Ortam Değişkenleri (Environment Variables) sayfasında PATH değişkenin değerine “C:\Program Files\Java\jdk1.8.0_144\bin” eklenir. Windows’da PATH değişkenindeki değerler arasın “;” koymayı unutmayın. Eğer PATH değişkeni tanımlı değilse, Yeni (New) tıklanarak açılan pencerede PATH değişkeni ve değeri tanımlanır.

Mac OS

Mac OS’da PATH için kullanıcı dizinindeki “.bash_profile” dosyasında aşağıdaki gibi tanım yapılması gereklidir:

export PATH = $PATH:/Library/Java/JavaVirtualMachines/jdk1.8.0_144/Contents/Home/bin

Zaten tanımlı bir PATH varsa JDK’nın bin dizinini sonuna ekleyin. Mac OS’da PATH’in değerlerinin arasına “:” koymayı unutmayın.

Linux

Ubuntu’da JDK kurulumuyla javac ve java gibi pek çok komut /usr/bin/ dizinde tanımlanmış ve /etc/alternatives dizinindeki linkler üzerinden JDK’in bin dizinindeki çalıştırılabilir komutlarla eşleştirilmiştir. Ubuntu’da /usr/bin/ dizini zaten PATH’dedir. Dolayısıyla Ubuntu’da PATH ayarı yapmanıza gerek yoktur. Fakat yine de Ubuntu’da PATH ayarı yapmak isterseniz /etc/profile dosyasına aşağıdaki satırı yazmanız gereklidir:

export PATH=$PATH:“/usr/lib/jvm/java-1.8.0-openjdk-amd64/bin”

PATH’in değerlerinin arasına “:” koymayı unutmayın. Terminal zaten açık ise, değişikliğin etkisi için kapatılıp yenisinin açılması ya da terminalde /etc dizininkeyken “source profile” çalıştırılması gereklidir.

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

]]>
http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-ii-java-kurulumu-ve-ilk-ayarlar/feed/ 0 6817
Java Kurulumu ve İlk Ayarları – I: Platformlar ve Java http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-i-platformlar-ve-java/ http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-i-platformlar-ve-java/#comments Sun, 20 Aug 2017 13:38:33 +0000 http://www.javaturk.org/?p=6805 Bu yazıda “bir makinaya Java nasıl kurulur” ve “kullanım için gerekli ilk ayarları nasıl yapılır”ı ele alacağız. Önce bazı tanımlarla işe başlayalım.

Platformlar

Platform: Donanım ve yazılımdan oluşan sisteme denir. Yazılım dünyasında platform ile, bilgisayar donanımı ve üzerinde çalışan işletim sistemi (İS) (operating system (OS)) kastedilir.

Platform = Donanım + İS

Örneğin, i7 gibi Intel CPU mimarisi (x86) üzerinde çalışan Windows (Wintel), Mac OS (MacIntel) ya da Linux işletim sistemleri farklı birer platformdurlar.

Platformaların en ayırt edici özelliklerinden birisi 32-bit ya da 64-bit olmalarıdır. Bu ayırım, Java (ve aslen 32 ve 64-bitlik ayrı sürümleri olan diğer yazılımlar) ile ilgili kurulumlarda yanlış yapmamak için önemlidir. Dolayısıyla platformunuzun 32/64 bitlik olduğunu daima bilin.

Bu burada aşağıdaki 3 platformu kullanacağız ve gerektiğinde Java açısından aralarındaki farklılıkları belirteceğiz:

  • Intel i7 CPU üzerinde Windows 10
  • Intel i7 CPU üzerinde Mac OS 10.12 (Sierra)
  • Intel i7 CPU üzerinde Linux Ubuntu (Mac OS 10.12’da Oracle VMBox üzerinde)

Platformların sürümleri arasında Java açısından zaman zaman ufak-tefek farklılıklar olabileceğini daima göz önünde bulundurun. Burada böyle durumlar karşılaşıldıkça belirtilecektir. Ayrıca Linux Ubuntu için anlatılanların farklı Linux paketleri için geçerli olmama ihtimali de söz konusudur. Dolayısıyla platformunuz farklıysa, geçerli olan kurulum ve ayarları kendinizin bulması gereklidir.

MS Windows

MS Windows’da genel olarak Control Panel’den giderek platformunuzun bit bilgisini öğrenebilirsiniz.

Control Panel=>System and Security=>System

Detaylı bilgi için: https://support.microsoft.com/en-us/help/827218/how-to-determine-whether-a-computer-is-running-a-32-bit-version-or-64 

Mac OS

Mac OS’da, sol üst kösedeki Apple logosuna tıklayıp, About This Mac => System Report => Hardware => Processor Name bilgisini buradaki liste ile karşılaştırın.10.6 Snow Leopard, 32-bit olarak çalışabilen en son Mac OS sürümüdür, bundan sonraki sürümler zaten 64-bittir. Ayrıca terminalde getconf LONG_BIT komutu da size 32 ya da 64 cevabını verecektir. Ya da yine terminalde uname -m komutu size x86_64 cevabını verirse 64-bitlik sisteme sahipsiniz demektir. Detaylı bilgi için: https://support.apple.com/tr-tr/HT201948

Linux

Linux Ubuntu ya da Debian’da System Settings => System => Details sayfasında sisteminizin kaç bitlik olduğu belirtilmiştir. Ayrıca Mac OS’taki gibi Ubuntu ya da Debian’da da terminalde getconf LONG_BIT komutu size 32 ya da 64 cevabını verecektir. Ve yine terminalde uname -m komutu size x86_64 cevabını verirse 64-bitlik sisteme sahipsiniz demektir.

JDK, JRE ve JVM

JDK, Java Development Kit’in kısaltmasıdır. Java SDK (Software Development Kit) de denir. Java ile kod geliştirmek için gerekli yazılım geliştirme kitidir. (Kit: Malzeme/alet takımı, çantası.) JDK, Java kodlarını derlemek (compilation), debug etmek, çalıştırmak (run) vb. işler için gerekli araçları içerir. JDK’da bulunan araçlardan en önemli ikisi, komut satırında aşağıdaki komutlarla çağrılır:

  • javac: Java derleyicisidir (compiler), Java kaynak kodlarını derler.
  • java: Java yorumlayıcısıdır (interpreter), Java’nın çalışma zamanı ortamını başlatır.

JDK, bir editör ya da IDE barındırmaz. Her platform için ayrı JDK gereklidir.

JRE, Java Runtime Environment’in kısaltmasıdır. Java’nın çalışma zamanı ortamını/yapısını temsil eder ve JVM ile Java kütüphanelerini barındırır. java komutuyla başlatılır.

JVM: Java Virtual Machine’in (Java Sanal Makinası) kısaltmasıdır ve derlenmiş Java kodlarının üzerinde çalıştığı yazılımdır, sanal bir makinadır.

Kütüphaneler ise JRE ile birlikte gelen ve kod yazmayı kolaylaştıran hazır yapılardır.

Java’da geliştirme yapmak için JDK, geliştirilmiş Java uygulamaların çalışması için JRE gereklidir. Yazılım geliştiricilerin makinalarında JDK, sunucu (server) makinalarında ve Java’nın üzerinde çalıştığı saat, telefon, araba vb. ortamlarda ise JRE bulunur. JDK, JRE’yi de içerir. Dolayısıyla, bundan sonra “Java’yı kurmaktan” ya da “bir ortamda Java olmasından” bahsettiğimizde aksini söylemedikçe daima JDK’yı kastedeceğiz.

Makinamda Java Var mı?

Geliştirici olarak makinamızda bize JDK gereklidir. Peki, bir makinada Java olup olmadığını nasıl anlarız? Bu soru daha detaylı olarak şöyle sorulabilir:

  • Makinamda Java var mı? Varsa
    • Sadece JRE mi var?
    • Yoksa JDK de var mı?

Bir makinada JDK olup olmadığını anlamanın en hızlı yolu komut satırını açıp “javac -version” komutunu çalıştırmaktır. JRE olup olmadığını anlamak için ise “java -version” komutu çalıştırılır. Bu komutlar bulunamazsa, o makinada JDK ya da JRE olmadığını söyleyemeyiz ama en azından gerekli ayarların yapılmadığını, dolayısıyla Java’ya komut satırından ulaşılamadığını söyleyebiliriz.

Benim makinamda “javac -version” çalıştırınca “javac 1.8.0_144” cevabını, “java -version” çalıştırınca da

java version “1.8.0_144”
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)

cevabını alıyorum. İkisi de aynı sürüm olduğuna göre yüksek ihtimalle JDK kurulu ve içinde JRE de var, nitekim durum bu. Ayrıca cevap, makinamdaki JVM’nin, 64 bitlik HotSpot sunucu için JVM olduğunu da söylüyor.

Ayrıca şu durumlara da dikkat etmek gereklidir: Bir makinada birden fazla, aynı ya da farklı sürümlerde, JDK’lar ve JRE’ler olabilir.  Her JDK içinde bir JRE vardır ama JDK olmaksızın, farklı JRE’ler de kurulmuş olabilir. Dolayısıyla komut satırından ulaşılan JDK ya da JRE, makinadaki tek kurulum olmayabilir.

Peki, eğer makinamda JDK(lar) ya da JRE(ler) varsa, nerededirler? Bu sorunun cevabı kolay değildir çünkü:

  • JDK ve JRE’nin, varsayılan yani hiç bir değişiklik yapılmadan kurulduğundaki yeri, farklı işletim sistemlerinde farklıdır, hatta aynı işletim sisteminin farklı sürümlerine göre de değişebilir.
  • Ayrıca kurulum sırasında varsayılan yer kullanılmayıp farklı bir yere kurulum yapılmış da olabilir.
Windows’da Java

Microsoft Windows makinalarda JDK ve JRE’nin varsayılan yeri “C:\Program Files\Java”dır.  Dolayısıyla bu dizinde bir ya da daha çok JDK ve JRE kurulum dizini bulunabilir, örneğin:

  • C:\Program Files\Java\jdk1.8.0_144

    C:\Program Files\Java\jre1.7.0_45

Microsoft platformları 32-bit ya da 64-bit olabilir. Dolayısıyla bu durum, 32-bit Windows’a 32-bit, 64-bit Windows’a 64-bit JDK (JRE) kurulduğunda böyledir. Eğer, 64-bit Windows’a 32-bit JDK (JRE) kurulursa, varsayılan kurulum patikası “C:\Program Files (x86)\Java” olur. 32-bit Windows makinaya ise 64-bit JDK (JRE) kurulamaz.

Mac OS’da Java

Mac OS, 64-bittir ve sadece 64-bit JDK’sı (JRE’si) vardır. JDK’nın (JRE’nin) tipik kurulumlarında varsayılan yer  “/Library/Java/JavaVirtualMachines/“ patikasıdır, örneğin:

/Library/Java/JavaVirtualMachines/jdk1.8.0_144

/Library/Java/JavaVirtualMachines/jre1.7.0_45

Linux’da Java

Linux platformları 32-bit ya da 64-bit olabilir. Bazı Linux dağıtımları Java kurulumuyla gelebilir. Örneğin Debian 9’da, OpenJDK 8 JRE vardır. Dolayısıyla, Debian 9’da JDK olmadığından “javac -version” çalışmaz ama “java -version” çalışır haldedir. Bu yüzden Java geliştirme için Debian 9’a JDK kurmak gereklidir. Ubuntu herhangi bir Java kurulumu ile gelmez, sizin kurmanız gereklidir.

Ubuntu ve Debian kurulduğunda, JDK’yı tipik olarak /usr/lib/jvm patikasına kurar. Ubuntu ayrıca bazı linkler de yaratır: javac ve java komutları /usr/bin/javac ve /usr/bin/java ile eşleştirilir. Dolayısıyla kurulumla beraber “javac -version” ve “java -version” çalışır gelir.

Bazı işletim sistemlerinde, sistemdeki Java kurulumları ile ilgili bilgi veren yapılar vardır. Örneğin, Mac OS’da “Java Control Panel”i vardır. Buna System Preferences => Java ile ulaşabilirsiniz.

Standart patikalarda JDK (JRE) bulunamazsa, geriye “javac” ya da “java” gibi çalıştırılabilir (executable) dosyaların tüm sistemde aranması kalır. Bunun için işletim sistemlerindeki arama (search) yapılarının kullanılması gereklidir. Dolayısıyla gerekmedikçe Java’yı varsayılan, patikaya kurmak yönetim açısından daha iyidir.

Bu yazıda platformumuza Java’yı kurmadan önce yapılamsı gerekenlerden bahsettik, bir sonraki yazıda kurulum ve ilk ayarları ele alacağız.

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

]]>
http://www.javaturk.org/java-kurulumu-ve-ilk-ayarlari-i-platformlar-ve-java/feed/ 2 6805
Programlama ve Kariyer http://www.javaturk.org/programlama-ve-kariyer/ http://www.javaturk.org/programlama-ve-kariyer/#comments Fri, 19 May 2017 15:05:01 +0000 http://www.javaturk.org/?p=6682 Mayıs ayı başında Malatya, İnönü Üniversitesi’nin düzenlediği Robocofest‘te katıldım ve “Programlama ve Kariyer” isimli bir sunum yaptım. Bu sunumun PDF dosyasına şu yazıdan ulaşabilirsiniz. Şimdi ise bu sunumu biraz daha geniş bir şekilde burada ele almak istiyorum.

Programalama nedir?

Bazı şeyleri, onları yapan, icra edenler üzerinden tanımlamak daha kolaydır. Programlama yapan kişiye programcı (programmer) denir. Peki, programcı kimdir? Programcı tabi ki kafein ve pizzayı yazılıma dönüştüren organizmadır 🙂 Bizim ülkemizde buna sigarayı da eklemek gerekir. Çünkü bekar olan ve muhtemelen bir kaç bekar arkadaşıyla aynı evde yaşayan, kariyerinin başındaki genç programcı arkadaşımızın odasına girdiğinizde hemen göze çarpacak şeylerin başında, izmaritle dolup taşmış küllükler gelir. Aynı odaya gece 2-3 gibi girerseniz dumandan programcıyı seçememe ihtimali de vardır.

 

 

Bir işi yapanı gözlemlemek o işle ilgili size çok şey anlatır. Dolayısıyla programcıları, tabi ortamlarında gözlemlemelisiniz. Programcıların kendilerine has hal ve hareketleri, çoğunlukla başkalarına garip gelir. Çok odaklı çalışırlar mesela, işin karmaşıklığı da zaten bunu gerektirir. O yüzden çalışırken rahatsız edilmek istemezler, açık ofis ortamlarında kulaklık takarak çalışmaları tam da bu yüzdendir. Bu sebepten, onların verimli çalışmalarını isteyen yöneticileri, programcıları zaman zaman aşağıdaki gibi korumaya alabilirler. Tehlikeli kimyasallarla ya da radyoaktif maddelerle uğraşanların da özel, korumalı ortamda çalışmalarından farklı bir şey değildir bu durum. Dolayısıyla bu fotoğraf

 

 

ya da bu fotoğraf,

 

 

programcılar için hiç de anormal değildir.

Peki geyiği bırakıp biraz ciddi olalım ve “hakikatten programlama nedir” diye soralım. Programlama kısaca,
• bilimdir (science),
• sanattır (art),
• mühendisliktir (engineering)
• ve zanaattir (craftmanship).

Programlama, her ne kadar harcıalem yani hemen herkesin yapabileceği, üstesinden kolayca gelebileceği bir şeymiş gibi görünse bile, aslen o kadar da basit değildir. Hayatımıza çok girmiş işleri genel olarak basite alma eğilimindeyizdir, taa ki onun içine girinceye kadar. Aslen “programlama nedir” konusunda daha önce burda bir dizi yazı yayınladım:

Bu yazılarda anlatmaya çalıştığım şey, programlamanın çok disiplinli (interdiciplinary) bir alan olduğu ve hiç bir şekilde harcıalem bir uğraşı olmadığıdır.

Yukarıda programlamanın neliği ile bu kadar uğraşmışken neden şimdi başka bir yazı yazdığımı sorarsanız eğer, burada daha çok programlamayı bir kariyer olarak gören gençlere yönelik bir kaç tavsiyem olacak. Ama bu tavsiyelerin anlam ifade etmesi ve bütünlük için için programlamanın neliğinden kısaca yine bahsetmek gerekecek.

Programlama Bilimdir.

Programlama, bilimdir çünkü programlama, matematiktir. Programlama, temelleri mantık ve cebir olan, aksiyomlara sahip, kendine has notasyonu olan bir uygulamalı matematik disiplinidir. Programlama ile genelde daima bir algoritma yazılır. İster çok karmaşık bir hesap yapın, mesela Newton Raphson yöntemiyle kök hesaplayın, ister bir sigorta poliçesinin fiyatını hesaplayın, isterseniz de KDV hesabı kadar basit bir şey yapın, daima bir algoritma yazarsınız. Grafik kullanıcı arayüzleriyle uğraşıyor olsanız ve bir düğme tıklanınca onun olayını (event) halletseniz de yazacağınız şey bir algoritmadır. Peki nedir algoritma?

Algoritma Nedir?

Tabi ki algoritma, programcıların ne yaptıklarını açıklamak istemediklerinde kullandıkları, mistik bir terimdir!

 

  • Nedir problem?
    • Algoritma abi!
  • Neden gecikti bu iş böyle?
    • Algoritmadan kaynaklanan bir problem var!

Tabi ki abartıyorum, keşke bu topraklarda iş alanı ile ilgili konuşmalarımızda algoritma vb. terimleri kullanarak formal konuşabilsek. Bizim konuşmalarımız daha çok “şu button tıklanınca falan şey gözükmüyor” tipinde, dıdının dıdısı cinsinden, hiç bir şekilde bağlamı içermeyen, detayda boğulan konuşmalardır. Bu problemin ne anlama geldiğini anlamak, başka yerlerde de olup olmayacağını ortaya çıkarmak için 2-3 soru daha sormanız gerekir! Neyse, algoritma, matematiksel bir ifadedir ve “bir işin yapılış şeklinin tarifidir öyle ki içinde iş kurallarının olduğu bir süreci barındırır” denebilir kısaca. Dolayısıyla program yazmak, algoritma yazmaktır, dolayısıyla matematiktir. Algoritmik düşünceyi daima sevmelisiniz iyi bir programcı olmak için. Bu yüzden üniversitelerde programlamayı, tipik olarak farklı türdeki algoritmalar üzerinden anlatırlar. Ama master yaparken saf algoritma dersi alırsınız, herhangi bir programlama dilinden bağımsız, sadece matematiksel, cebirsel bir faaliyet olarak öğrenirsiniz algoritmaları. Hatta güvenlik (security) vb. konularda apayrı yapıda algoritmalara odaklanırsınız.

Geyik de olsa algoritma kelimesine yüklenen “karmaşıklık” algısı aslen, her meslek gibi programcıların da kendilerine has bir dilleri olduğunu ifade etmeye yarar. İngilizce’de “sadece ehlinin bildiği” anlamına gelen “esoteric” terimi kullanılır bu gibi durumlar için. Bu topraklarda her ne kadar henüz örneğin doktorlar kadar formal ve esoterik konuşamazsak da programcılık, tamamen esoterik bir dile sahiptir. Matematiksel tabanlı olan bu esoterik dili ne kadar iyi bilirseniz o kadar iyi programcı olursunuz.

Programlama Sanattır.

Soyut oluşu ve örneğinin olmaması, yaratıcılık gerektirmesi ve yapanın kişisel özelliklerine bağlı olması, programlamayı bir sanat yapar. Programlama matematiktir dedik ama zaten matematikte de sanatsal taraf yok mudur sizce? Hemen hiç bir programlama yapısı bir diğerinin aynısı hatta benzeri bile değildir, her programlama birimi kendi başına tekildir, “unique”dir. Aynı sanat eserleri, tablolar, müzik eserleri, filmler, romanlar gibi. Dolayısıyla ciddi bir kurgu içerirler.

Programlamayı sanat görenlerin başında, bu dünyaya en çok emeği geçmiş, Stanford Üniversitesi’nden emekli, Donald Knuth gelir. Çok özel ilgi duymuyorsanız muhtemelen sadece doktora yaparken karşılaşacağınız kitaplardan olan, Knuth’un en büyük eseri The Art of Computer Programming‘in  ismi de bunu yansıtmaktadır. Knuth bu kitabında programlamadaki estetik tecrübeye de vurgu yapar.

 

 

 

 

 

 

 

 

Programcılar, yaptıkları işi tanımlarken, “aşk”, “tutku”, “bağımlılık” gibi kelimeleri çok kullanırlar. Muhtemelen, zekanın çıktısını, programlama kadar açık ve hızlı görebilen fazla meslek uğraşı yoktur. Bu yüzdendir ki normal insanlar uyanmak, programcılar uyumak için saat kurarlar!

 

Programlama Mühendisliktir.

Programlama bir problem çözme yöntemidir, programlama amaç değil araçtır. Süreçseldir, kodun geliştirilmesi, testlerinin yazılması ve çalıştırılması, dokümantasyonu vb. çalışmalar, programlamanın parçalarıdır. Bu yönüyle programlama bir mühendislik disiplinidir.

Yazılım Geliştirme Nedir?

Yazılım geliştirme, merkezinde programlamanın olduğu bir mühendisliktir. Yazılım Mühendisliği (Software Engineering), programlama yanında, analiz, tasarım, test, yönetim vb. faaliyetlere sahiptir. Fakat programlama, esas çıktıyı üretendir, dolayısıyla koskoca projedeki tüm hata, performans, gecikme vb. şeylerden hatta faturanın kesiminden bile sorumlu olan kısımdır. (Bu sebeple, mesela ülkemizde yazılım mühendisliğini programlamaya indirgeme, ya da programcılığı, yazılım mühendisliği olarak görme eğilimi çok yaygındır.) Bu yüzden programcılık cesaret ister!

 

Programlama Zanaattır.

Usta-çırak ilişkisi ile öğrenilmesi, ciddi el (ve zihin) yatkınlığı gerektirmesi ve yapanın kişisel özelliklerine bağlı olması, programlamayı, bir zanaat (craftmanship) kılmaktadır. Her zanaatta olduğu gibi programlamada da kullanılan araçlar ve iş yapış şekilleri vardır.

 

Diğer Mühendislikler Arasında yazılım Mühendisliği

Programlama da, yazılım geliştirme de çok karmaşıktır, muhtemelen mühendislikler arasında en karmaşık olandır.

 

Ama herşeye rağmen yazılım geliştirme takımının görevi, basitlik illüzyonu yaratmaktır. Belki de tam da bu yüzden programcılık ve yazılım geliştirmek ülkemizde, harcıalem bir uğraşı olarak görülmektedir.

Programcı Olmak İçin

Yukarıda anlattıklarım, belli bir bilgi temelini, zihinsel işleyişi ve nihayetinde çalışma şeklini vurguluyor. Elbette çalışma ile herkes herşeyi yapabilir, başarabilir. Ama mutlu olur mu ya da fark yaratır mı? Sanırım bu sadece çalışma ile ilgili bir durum değil, belki, sevme, tutkuyla bağlanma, uygun olma gibi kavramlar giriyor işin içine.

Bence iyi bir programcı olmak için şu özellikler düşünülmeli:

  • Farklı soyutlama seviyeleri arasında rahatça gezebilen, matematiksel bir zeka,
  • Aynı anda pek çok faktörü yönetebilen detaycı bir zeka,
  • İğne ile kuyu kazabilen bir sabır taşı ve tutkulu bir psikoloji.

Özellikle Türkiye’de, tüm bunların altından kalkabilmek için strese de dayanıklı olmalısınız. Programcılık keyiflidir ama bu ülkede keyifsiz insanlar, programcılığı eziyete dönüştürürler.

Eğer programlama konusunda, kendinizi yukarıdaki özelliklere sahip görüyorsanız, iyi bir programcı olabilirsiniz hatta olun, insanlığa katkıda bulunun. Aksi taktirde bu dünyanın sonu değildir, bilgisayar mühendisliği vb. bir bölümde okuyor olsanız bile, kariyerinizde mutlu olmak için analist, tester, ağ, veri tabanı, vb. sistem yöneticisi vb. pozisyonları tercih etmeyi düşünün.

Programlama-Yazılım Kültürümüz

Açıktır ki, ülkemizdeki programlama kültüründe zanaat tarafı ağır basmaktadır. Zanaatlarda da, ülkemizdeki programlama pratiğinde de, öğrenmede formal eğitim yerine bakıp-görerek öğrenme, problem çözmede de sistematiklik yerine deneme-yanılma ile çözme, iş yapış şekillerinde yaratıcılık yerine araçlara ve teknolojiye bağlı kalma öne çıkmaktadır. Ülkemizdeki programcıların en büyük yardımcısı copy-paste ve Google’dır. Bu anlamda programlama ve yazılım geliştirme kültürümüz, toplumsal kültürümüzün bir yansımasıdır. Bu yüzden sıradan bir programcı olmak yerine fark yaratmayı hedefliyorsanız zanaatkar olmakta ileriye gitmeye çabalamalısınız. Bu yüzden:

  • Formal eğitime muhakkak önem verin. Yani üniversite 2. sınıfta iken “Java’yı ve Android’i öğrendim, şimdi ne öğreneyim” diye sormayın. Matematiğiniz 90 ve üzerinde mi? Algoritmalar ve Veri Yapıları dersinden sınıfın en iyisi misiniz? Bu sorulara hayır diye cevap veriyorsanız sorduğunuz soru zaten yanlış bir sorudur. Hele üniversitede BM’e girdiği ilk sene, binlerce lira para vererek şehrideki bir kursa yazılıp, Windows makinanın TCP/IP ayarlarının nasıl olacağını öğrenmeyi marifet sayanlardan olmayın. İşletim Sistemleri dersinden zor geçip sonra Linux öğreneceğim diye de yırtınmayın. Linux’te komut satırında ihtiyacını giderecek kadar bir şeyler yapmak ya da yasaklarla boğuştuğumuz canım ülkemizde bir kaç IP ayarını hızlıca yapabilmek, işte tüm bunlar zanaatin ta kendisidir! Dolayısıyla Linux öğrenin ama bir Linux de ben nasıl yazarım diye hedefleyin. Algoritmaları ezberlemeyin, şunu şöyle seçseydik nasıl çalışırdı diye akıl yürütmeyi alışkanlık edinin. Temel derslere, işletim sistemleri, algoritmalar, db, network, discrete matematik, vb. çok önem verin. Formal eğitiminizi çalışırken de devam ettirin, master-doktora yapın, sertifika alın örneğin.
  • Sistemli çalışın. Sistemli çalışmak için muhakkak, temelden ileriye doğru gidin ve odaklanın. Kerat cetvelini bilmeden integrali öğrenmeye kalkmayın, öğrenemezsiniz çünkü, sadece ezberlersiniz ve başarısız olursunuz.
  • Odaklanın. Aslında odaklanmak, sistemli çalışmanın bir alt parçası ama önemine binaen ayrı bir başlık altına aldım. Çok sıklıkla görüyorum, ilgisiz pek çok konuyu abur-cubur bir şekilde öğrenmeye çalışanları. Zaten bu şekilde öğrenme de olmuyor, bilgi sahibi olmadan fikir sahibi olunuyor. İyi tanımlanmış ve özelleştirilmiş, spesifik hedeflere sahip olun.  Örneğin 3 senelik BT çalışanı, hem PM sertifikası almış şimdi de SQL eğitimi alıyor, seneye de Cisco kursuna gitmekten bahsediyor! Nedir şimdi bu? Eğer PMP, SQL ve Cisco ile bir şey başarılabiliyorsa, bunları gerekli kılan bir hedef varsa eyvallah ama aksi taktirde zaman, enerji ve zeka kaybı!

Bu türden eleştiri ve tavsiyelere, bizim sektöre katılacak gençlerden çok aslında sektörümüzün ve üniversitelerimizin ihtiyacı var, bunun çok fena şekilde farkındayım. Siz istediğiniz kadar iyi olun sektörümüz iyiyi aramıyor, iş bitiriciliğe prim veriyor. Ya da üniversiteler hatta çok daha öncesinde başlayan eğitim sistemimiz, edep-terbiye adı altında sorgulamamayı, ezberlemeyi kutsamış durumda. Dolayısıyla yurt dışına gitmeyi, gerek eğitim gerek profesyonel olarak çalışmak amacıyla oralarda bir miktar yaşamayı kesinlikle hedef edinin. Yukarıdaki tavsiyelere ne kadar uyarsanız bunu yapmak o kadar kolay olacaktır.

Programlama, keyiftir 🙂

 

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

]]>
http://www.javaturk.org/programlama-ve-kariyer/feed/ 2 6682
Programlama ve Kariyer Sunumu http://www.javaturk.org/programlama-ve-kariyer-sunumu/ Tue, 16 May 2017 04:10:18 +0000 http://www.javaturk.org/?p=6668 Mayıs ayı başında Malatya, İnönü Üniversitesi’nin düzenlediği Robocofest‘te katıldım ve “Programlama ve Kariyer” isimli bir sunum yaptım. Sunuma aşağıdaki bağlantıdan ulaşabilirsiniz.

Programlama ve Kariyer
Programlama ve Kariyer
Programlama-ve-Kariyer-06052017.pdf
1.3 MiB
236 Downloads
Ayrıntılar

Ayrıca hem İnönü Üniversitesi’ne, hem bu etkinliğin sponsorlarına hem de bizi güleryüzle karşılayan ve rahat etmemiz için etrafımızda koşuşturan öğrenci arkadaşlar çok teşekkür ederim.

İyi okumalar 🙂

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

]]>
6668
Java ile Nesne Merkezli Programlamaya Giriş Eğitimi http://www.javaturk.org/java-ile-nesne-merkezli-programlamaya-giris-egitimi/ Fri, 30 Dec 2016 09:13:31 +0000 http://www.javaturk.org/?p=6635 Sevgili Java-severler,

Verdiğim eğitimlerden olan “Java ile Nesne Merkezli Programlamaya Giriş”in kendi hazırladığım konu anlatım sunumlarını ve derste kullandığım tamamı kendime ait olan örnek kodlarını zaten Java Dersleri sayfasında öteden beri paylaşmaktaydım. Bu sayfada artık bu eğitimin konu anlatımlarını içeren videoları da var. Youtube’da oluşturduğum bir çalma listesi (play list) içinde var olan 39 tane video ile bu dersin yaklaşık 17 küsür saatlik konu anlatımlarını seyredebilirsiniz. Dolayısıyla yapmanız gereken, sunumlar ile örnek kodları içeren projeyi indirmeniz, projeyi Eclipse’de açarak çalışabilir hale getirmeniz ve sonrasında da Youtube’daki videoları seyrederek Java’yı öğrenmeye başlamanızdır.

Programlama dili öğrenmek zordur, çok ve sık, sürekli okumak ve kod yazarak, var olan kodu evirip çevirerek, ufak-tefek projeler yazarak, pratik yapmak gerekir. Ülkemizdeki programcılık kültürü, zanaat kültürüdür, dolayısıyla formal bir eğitime ve bilgiye dayanmadan, sadece bakarak-görerek ki modern zamanlarda bakılıp görülen yer ya var olan koddur ya da Google’dır, derme çatma, gelişi güzel, “çalışsın yeter” anlayışıyla kod yazıp ve yazılım geliştirdiğimizden, malesef bu tür formal öğrenim ve öğretim imkanlarına yeterince değer vermiyoruz. Bu videolarla çok daha formal bir şekilde, sistemli olarak, en başından itibaren Java’yı öğrenebilirsiniz. İyi bir developer olmak, Java sertifikalarını almak hatta  hatta yurt dışına çıkmak isteyenler için faydalı olacağını umuyorum.

Eğitimlerdeki her türlü eksiklik ya da yanlışlık için için şimdiden özür dilerim. Bu konularda beni uyarırsanız sevinirim.

Bol Java’lı günler dilerim 🙂

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

]]>
6635
Agile Summit Turkey 2016 http://www.javaturk.org/6605-2/ Wed, 28 Sep 2016 08:27:30 +0000 http://www.javaturk.org/?p=6605 Sevgili Javaseverler,

6 Ekim’de yapılacak olan Agile Summit Turkey 2016 etkinliğinde olacağım nasipse. Orada olanlarla tanışıp sohbet etmekten keyif alırım.

Ayrıca ertesi günü 1 günlük Design Patterns eğitimim olacak, ona gelmek isteyen olursa yine bu sayfanın altındaki eğitimler kısmından ilerleyerek kayıt yaptırabilir.

Design Patterns @ Agile Summit

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

]]>
6605
Yaratımsal Kalıplar (Creational Patterns) http://www.javaturk.org/yaratimsal-kaliplar-creational-patterns/ http://www.javaturk.org/yaratimsal-kaliplar-creational-patterns/#comments Thu, 15 Sep 2016 16:02:25 +0000 http://www.javaturk.org/?p=6565 Yaratımsal kalıpları (creational patterns) ele aldık ama bu konu hala bir yazıyı hakediyor. Çünkü yaratımsal kalıpların arasındaki ilişkileri ve hepsinin bir arada nesne yaratma problemini nasıl çözdüklerini görmek, nesne yaratma problemini ve çözümlerini bir arada görmek açısından çok faydalı olacaktır.

GoF’da 5 tane yaratımsal kalıp vardır. Bunlardan Singleton, diğer dördünden farklı ele alınabilecek yapıdadır. Çünkü Singleton, “nesne yaratma” hakkında bir kalıp değildir. Yani Singleton, nesnenin ya da nesnelerin nasıl yaratılacağıyla ilgili değildir, o çok daha özel bir problemi çözer: Bir sınıftan sadece ve sadece bir tane nesne nasıl yaratılır? Dolayısıyla Singleton‘u kenara koyarsak, geriye kalan dört kalıbı ve aralarındaki ilişkileri ele alabiliriz.

Singleton‘u çıkardığımızda geriye kalan dört kalıptan ikisi, Factory Method ve Abstract Factory, diğer ikisinden yani Builder ve Prototype‘tan görevleri itibariyle ayrılırlar. Dolayısıyla, geriye kalan dört kalıp, iki ayrı grupta ele alınabilir. Aralarındaki fark, ilk grubun yani Factory Method ve Abstract Factory kalıplarının nesne yaratmayı soyutlamalarına rağmen diğer iki kalıbın, yani Builder ve Prototype‘ın nesne yaratmayı soyutlamak yerine nesne yaratma mekanizmasını gerçekleştiriyor olmalarıdır. Bir başka deyişle, Factory Method ve Abstract Factory kalıplarının esas hedefi, nesne yaratma kodunun ortalıkta gezinmesini yani nesne yaratan kodların tekrarını önlemek ve bu kodları tekrar kullanılabilecek şekilde soyutlamaktır. Dolayısıyla Factory Method ve Abstract Factory kalıplarındaki metotlarda nesnelerin nasıl yaratılacakları, bu kalıpların çözdüğü bir şey değildir. Factory Method ve Abstract Factory kalıpları, “nesneleri nerede yaratalım?” sorusunun cevabıdırlar. Bu sorunun cevabını Factory Method ya da Abstract Factory olarak verdikten sonra soru değişir. Nesnenin nerede yaratılacağı belli olduğuna göre soru artık  “nesneyi nasıl yaratalım?”dır. Builder ve Prototype kalıpları ise GoF’un bu soruya verdikleri cevaplardır.

Malum,”nesneyi nasıl yaratalım?” sorusu klasik olarak iki cevaba sahiptir: ya kurucu çağrısı ile bütün gerekli veriyi parametre olarak geçerek nesne yaratma ya da önce varsayılan kurucu çağrısı ile en temel durumda nesne yaratma ve sonra da set metotları ile nesneyi istenilen duruma getirme. Bu ikinci durum “JavaBean modeli” olarak bilinir. Buna bir de Joshua Bloch’ın Effective Java kitabında tavsiye ettiği statik factory metodu yaklaşımı eklenirse, alternatifler 3’e çıkar.

Bu iki sorulu ayrım ve cevapları aşağıdaki şekilde özetlenmiştir:

Object Creation

Şimdi bu ayrımı aşağıdaki örnekte ele alalım.

Örneğin elimizde bir tane Car sınıfı var ve uygulamada bu sınıfın değişik nesnelerini oluşturmamız gerekiyorsa, nesne oluşturan kodları bir Factory Method’un içine koyarız. Yok elimizde Car ile beraber Engine, Brake, Wheel, Door vb. sınıflar da varsa ve bu sınıfların nesnelerini biz bir arada oluşturuyorsak, bu durumda her birisi için gerekli olan Factory Method‘unu bir sınıfın içine koyar ve Abstract Factory‘i elde ederiz. (Açıkçası  Factory Method, AbstractFactory‘nin tek nesne için olan halidir. Bu yüzden ikisinin Factory adıyla tek bir kalıp olarak ele alınması daha iyi bir durum olur. Fakat GoF, bir hata yapıp ikisini ayırmış ve nihayetinde karmaşaya yol açmıştır. Bu konuda buraya bakılabilir.) Hatta eğer farklı Car nesneleri için Brake, Wheel, Door vb. sınıfların farklı durumda nesneler oluşturuluyorsa, bu halde her nesne ailesi için ayrı bir Abstract Factory sınıfı oluştururuz.

Buraya kadar sistemde var olan CarBrake, Wheel, Door vb. sınıfların nesnelerinin nerede oluşturulacağı ile ilgili gerekli yapıyı kurguladık ama ister Abstract Factory olsun ister Factory Method olsun, nihayetinde nesne oluşturan üretici yani factory metotlarının içinde nesneleri gerçekte nasıl üreteceğimizi konuşmadık. İşte şimdi de bu kısma geldiğimizde elimizde hangi alternatiflerin olduğunu ele almalıyız.

Factory Method ve Abstract Factory kalıplarında nesneleri üretmek için temelde beş yöntemimiz vardır. İlk ikisi ve handikapları şöyledir:

  • Kurucu (constructor) çağrısı: En iyi bilineni parametreli kurucu çağrısı ile nesne oluşturmak. Kurucular, isimlerinin aynı olmasınan dolayı karıştırılılar ve çoğu zaman hataya yol açarlar. Ayrıca artan parametre sayısı kurucu çağrılarını gittikçe zorlaştırır.
  • JavaBean yaklaşımı: Varsayılan kurucu ile nesneyi oluşturup set metotlarıyla nesneyi istenilen duruma getirmek. Bu yaklaşım da kurucu çağrısı gibi problemlidir, hataya yol açabilir.

Yukarıdaki iki alternatif de basit nesnelerin oluşturulması için kullanılmalıdır. Basit nesnelerden kasıt ise kurucusuna geçilen parametre sayısı ya da JavaBean yaklaşımında çağrılacak set metodu sayısı 3-4’ü geçmeyendir. Hele JavaBean yaklaşımında set edilecek durum parametreleri arasında bağımlılık varsa ve bu set metotlarının çağrı sırasını belirliyorsa bu durumda hataya çok elverişli bir durum var demektir, kaçınılmalıdır. Bu halde aşağıdaki yollar tercih edilmelidir.

Peki, geriye kalan üç alternatif nedir:

  • Joshua Bloch’ın statik factory metotları: Joshua Bloch, Effective Java kitabında, nesne oluşturmak için, sınıfta tanımlanan karmaşık yani çok argüman alan kurucular yerine, anlamlı isimlere sahip statik factory (nesne üretici) metotları önermektedir. Buna göre kurucular private yapılır ve var olan her kurucu için,aynı sınıfta, statik, nesne yaratan yani factory metotlar oluşturulur öyle ki bu metotların isimleri, yarattıkları nesnenin durumunu göz önüne alacak şekilde verilir. “createAuthenticatedUnvalidatedCorporateUser” gibi isimlerle, hem kullanıcının durumuyla ilgili geçilecek ikisi muhtemelan boolean tipinde, üç ya da daha fazla  argümandan kurtulunmuş olur hem de kurucuların isimlerinin aynı olmasının getirdiği karıştırma problemi oradan kalkar. Bu konuda ayrıntılı bilgi için Bloch’ın Effective Java kitabına bakılmalıdır.
  • Builder (İnşacı): Eğer nesne karmaşık ve bu karmaşıklık nesnenin oluşturulma şeklini de belirliyorsa, nesnenin oluşturulması bir süreç gerektiriyor demektir. Bu durumda nesnenin yaratılmasından değil de oluşturulmasından, inşa edilmesinden bahsedilir. Bu şekilde, nesneyi bir süreç dahilinde oluşturmayı öneren kalıp, Builder ya da İnşacı kalıbıdır. Dolayısıyla karmaşık nesneler, bir süreç dahilinde bu kalıp ile oluşturulmalıdırlar.
  • Prototype (Örnek Nesne): Prototype da Builder gibi, oluşturulması zor dolayısıyla da yüksek karmaşıklıktaki nesnelerin yaratılması içindir ama ufak bir farkla. Prototype, yeni nesneyi, var olan bir nesneden oluşturur. Yani önce var olan örnek (prototype) nesneyi kopyalayar (clone) sonra istenilen duruma getirir. Bu yüzden, Prototype kalıbının odağı, durumdan (state) kaynaklanan karmaşıklıktır. Bu da şu anlama gelir: Eğer nesnenizin karmaşıklığı, nesnenin sahip olduğu durumlardan kaynaklanıyorsa, yani nesneniz iş için belirlenmiş bir kaç durumdan birinde olması gerekiyor ve developerların hepsinin bu durumları detaylarıyla bilmesi zor ise, o nesneyi bu durumlardan birinde oluşturmak zor ve hataya elverişli bir durum var demektir. Bu durumda nesneyi sıfırdan oluşturmak yerine, arzu ettiğiniz durumda olan bir nesneyi kopyalayarak elde etmek daha kolay olur. Bu da Prototype kalıbıdır.

Yukarıdaki alternatiflerle ilgili şunlar söylenebilir:

  • Nesneleri daima bu işe hasredilmiş üretici (factory) sınıflarında oluşturun. Oluşturulacak nesneler birbirleriyle ilgili değillerse, her birisi için bir Factory Method kullanın, yok nesneler bir arada kullanılıyor ve muhtemelen de beraber oluşturuluyorsa, bu durumda nesne ailelerinden bahsediliyor demektir ve bunun için Abstract Factory‘i kullanın.
  • Factory Method, AbstractFactory‘nin tek nesne için olan halidir. Dolayısıyla Abstract Factory, Factory Method‘u kullanır. (Aslen her iki kalıp da Factory isimli genel kalıbın altında ele alınmalıdır.)
  • Factory Method (dolayısıyla da AbstractFactory), nesne oluşturmak için Builder ya da Prototype kalıplarını kullanabileceği gibi, nesneyi yaratmak için kurucu cağrısı, JavaBean yöntemini ya da Bloch’ın statik factory metotlarını da tercih edebilir.
  • Belki garip gelecek ama yukarıdakinin tersine, Builder da Factory Method‘u (dolayısıyla da AbstractFactory) kullanabilir çünkü nesneyi inşa sürecinde muhtemelen pek çok, esas nesnenin ihtiyacı olan diğer, muhtemelen farklı türlerden nesneler de oluşturulacaktır. Benzer şekilde esas nesnenin inşa sürecinde gerekli diğer nesnelerin yaratılması için, kurucu cağrısı, JavaBean modeli ya da Bloch’ın statik factory metotları da kullanılabilir.

Aşağıdaki şekil, yukarıda anlatılan seçenekleri ve kalıplar arasındaki ilişkileri özetlemektedir.

Creational Patterns

 

Bu yazıda nesne yaratmayla ilgili hem kalıpları hem de klasik diğer yolları ve Bloch’un önerisini ve aralarındaki ilişkileri ele aldık. Bu şekilde konu ile ilgili büyük resmi görmeye ve daha analitik bir anlayışa sahip olmaya çalıştık.

 

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

]]>
http://www.javaturk.org/yaratimsal-kaliplar-creational-patterns/feed/ 2 6565
Kod Analizi: Kurucu Kullanımı http://www.javaturk.org/kod-analizi-kurucu-kullanimi/ http://www.javaturk.org/kod-analizi-kurucu-kullanimi/#comments Mon, 08 Feb 2016 10:48:02 +0000 http://www.javaturk.org/?p=6527 Danışmanlık verdiğim yerlerde her zaman farklı yaklaşımlarla yazılmış kodlar görüyorum. Bu tür kodların ufkumu açtığında şüphe yok. Ama açıkçası her ufuk açmanın iyiye ve güzele doğru olduğunu söylemek zor.

Aşağıdaki kod da bu şekilde karşılaştığım kodlardan. Tabi ki ciddi miktarda kamufle edilmiş isimler içeriyor. Ama koddaki yaklaşım, arka taraftaki düşünce vs. tamamen korunmuş durumda. Kod şöyle:

public JTUser execute(RegistrationForm form, 
          HttpServletRequest request, Locale locale)    
          throws JTException {

	String uid = Utils.generateUUID();
	String salt = Utils.generateSalt(32);
	String accountId = Utils.generateUUID();

	JTUser user = new JTUser(form.getEmail().trim(), null, true, true, 
                          true, true, AuthorityUtils.NO_AUTHORITIES, uid, 
                          form.getEmail().trim(), salt, 
                          form.getName().trim(), form.getSurname().trim(), null, accountId, true,
		          true, form.getWelcomeMessage().trim(), true, new Date(), null);

	user.setStatus(JTConstants.PENDING);

	String servletPath = request.getServletPath();
	if (executeInner(form, locale, user)) {
	    auditLogDao.insert(new AuditLog(user.getUid(), user.getUsername(), Utils.getRemoteIp(), Utils.getSid(),
		               AuditType.REGISTRATION, AuditSubtype.PENDING, ResponseCode.SUCCESS, 
                               new Date(), null));
	    authenticateFastRegisterUser(form, request);
	}

    return user;
}

Bu metodu analiz etmek istersek, hem nesne-merkezli programlama hem de temiz kod gibi noktalardan inceleyebiliriz. Önce şekilden başlayıp sonra kodu yazanların sahip oldukları, en azından koda yansıttıkları anlayışa doğru gidebiliriz. Bu yüzden önce isimlerden başlayalım.

Mekanı kullanma

Yukarıdaki kodda düzgün olan nedir diye sorsam, olsa olsa “sadece paragraflar” denebilir çünkü isimlendirme bile problemli. Ama açıkçası bir kodun paragraflandırılmış olması, yani bir geliştirme aracının iki-üç tuşa basımlık bir işini meziyet olarak ortaya koymak mümkün değil. Öte taraftan JTUser kurucu ve insert metot çağrılarının, kodda hüküm süren yaklaşımdan dolayı mekanı zorunlu olarak iyi kullanamadıkları da bir gerçek.

İsimlendirme

Çoğu zaman kodu yazanların kafalarındaki karmaşıklığı verdikleri isimlerden çıkarabilirsiniz. Bu kod parçasında da execute ve executeInner metotları, bu metotları yazanların kafalarındaki karmaşıklığa bir örnektir. Biraz empati yapıp, execute metodunun Command tasarım kalıbından esinlendiği düşünülebilir. Bu durumda daha geniş bağlama bakıp hakikatten bu kalıbın kullanıp kullanılmadığına karar verilebilir. Diyelim ki Command kalıbı kullanıldı ve bu metodun bulunduğu sınıf, kalıptaki arayüzü gerçekleştiriyor ve bu yüzden metodun ismi, Command kalıbının geleneğine bağlı kalınarak execute olarak verilmiş olsun. Peki executeInner‘ı ne yapacağız? executeInner metodunun içinden çağrılan metotların isimlerini tahmin edebilir miyiz? executeIpInner, executeDahaDaInner ya da executeInner2 diye gidebilir 🙂  Bu kadar kötü ve ezbere bir isimlendirme olursa, daha fazla düşünce ve tecrübe gerektiren, daha zorlu algoritmik ve modelleme problemlerinde nasıl bir yaklaşım olabilir, tahmin etmek zor değil.

Bir diğer isimlendirme problemi de authenticateFastRegisterUser metodu için söz konusu. Bu metot hali hazırda sisteme kayıtlı olan kullanıcının hızlı olarak sisteme girmesini sağlıyor gibi duruyor. Bu durumda metot isminin authenticateFastRegisteredUser olması gerekirdi.

Yaklaşım

Bu kod parçasında temelde JTUser oluşturulup executeInner‘a geçiliyor ve dönen değer true olduğunda göre  audit bilgisi AuditLog nesnesi olarak oluşturulup, veri tabanına gönderiliyor ve user sisteme dahil ediliyor. Bu işler olurken kodda göze batan iki yer var, iki nesnenin oluşturulması. Bu iki nesne için tabi olarak ikş kurucu çağrısı yapılıyor ve bu çağrılar o kadar kötü kurgulanmış ki insan hayret ediyor. Şu çağrıya bakın örneğin:

	JTUser user = new JTUser(form.getEmail().trim(), null, true, true, 
                          true, true, AuthorityUtils.NO_AUTHORITIES, uid, 
                          form.getEmail().trim(), salt, 
                          form.getName().trim(), form.getSurname().trim(), null, accountId, true,
		          true, form.getWelcomeMessage().trim(), true, new Date(), null);

Bir kurucuya neden nesneyi doğrudan geçmek yerine parçalarını ayrı ayrı geçersiniz ki? Bu kurucuya form nesnesinin email, name, surname ve welcomeMessage alanları ayrı ayrı geçiliyor. Aslen sadece form nesnesinin geçilmesi gerekirdi. Bu durum nesne-merkezli programlamanın pek özümsenmediğini açıkça gösteriyor.

Öte taraftan, bir metoda neden new Date() ile o anki zamanı geçersiniz? İki şeyden dolayı, ya geçilen yerde o anki zamana ulaşamıyorsunuzdur,  yani kurucuda new Date() yazamıyorsunuzdur :), ya da o kadar ince hesaplarla çalışıyorsunuzdur ki, önemli olan execute metodundaki zamandır, bir nano saniye sonra JTUser kurucusundaki an işinize yaramıyordur 🙂 Açık ki burada bu iki durum da söz konusu değildir.

Başka ne gibi problemler var bu kurucu çağrısında? null geçilmesi problemdir. Üç parametre null olarak geçiliyor ve muhtemelen başka yerlerdeki aynı kurucu çağrısında null geçilmiyordur. Bu durumda da kurucuda devamlı null kontrolü yapılmalıdır. Aslen hep null geçiliyorsa bu daha büyük bir problemdir çünkü bu o nesnenin zaten bu kurucuya hiç geçilmemesi gerektiğini gösterir. Yok ilk durum geçerliyse yani bazen null geçiliyor bazen de değer geçiliyorsa bu zaten sıkıntılı bir yapı ortaya koyar çünkü null geçmek ya da null döndürmek hataya sebebiyet verir.

Kurucuya geçilen diğer üç parametre yani uid, salt, accountId, de geçilmemelidir çünkü bu üç değer zaten Utils sınıfından statik metotlarla alınabilir. Ne farkeder ki, ha orada ha burada demeyin, en az parametre geçecek şekilde kod yazmamız gerekli. Aksi taktirde bağımlılıkları gereksiz yere arttırmış oluyoruz.

Geriye bu kurucuya geçilen yedi tane true parametresi kalıyor. Bu parametreler belli ki JTUser nesnesinin belli bir durumda (state) oluşmasını sağlıyorlar. Ama bir nesnenin durumunda yedi tane boolean değişken yer alması biraz garip değil mi? Bu yedi değişken toplamda 2^7 = 128 farklı durumu temsil eder. Bu durumda JTUser nesnesinin en az 128 farklı hali var demektir. Örneğin yeni kayıt olmuş ama henüz teyit edilmemiş kullanıcı, yeni kayıt olmuş ve teyit edilmiş kullanıcı, vs. diye gidebilir. Problem şu: Her ne kadar biz metotları, onlara az parametre geçilecek şekilde tasarlayalım desek de kurucularda böyle yapmak imkansızdır. Yani kurucular nihayetinde oluşturdukları nesnelerin durumlarından sorumlu oldukları için genelde çok sayıda parametre alırlar. Bu türden kuruculara, parametrelerden dolayı uzun olduklarını ifade etmek için “teleskopik” denir. Biz yukarıda saydığımız sıkıntıları giderecek şekilde kodu tekrar yazsak bile kurucular hala çok parametre alır halde kalırlar. Örneğin JTUser kurucusunun 20 olan parametre sayısını 8’e indirmiş oluruz, ve bu hale gelir:

	JTUser user = new JTUser(form, true, true, true, true, true, true, true);

Garip değil mi? Garip olan şey bu kurucu metodun uzunluğu değil, çağrılmasındaki zorluk. Yedi tane arka arkaya gelen boolean parametrenin hangisinin ne olduğunu ve ne işe yaradığını bilmeniz gerekli. Muhtemelen bu kurucu metot şöyle tanımlanmıştır:

...

public JTUser(Form form, boolean verified, boolean authorized, boolean authenticated, ...){
   ...
}

...

Çok fazla sayıda parametre içeren metot yazmanın kaçınılmaz sonuçlarından birisidir bu durum. Normal metotlarda, metotları bölüp parçalayarak, sadece br işe odaklar hale getirip  bu durumdan kaçınabiliriz. Fakat metotların ismi olmasına karşın kurucuların ayırt edici isimleri yoktur. Ve özellikle de karmaşık nesnelerde hem pek çok kurucu vardır ama hangisinin, hem de kurucuların kendileri uzundur. Dolayısıyla hangi kurucunun çağrılacağı ve hangi parametrelerin geçileceği, zaman alan bir kodlama gerektirir ve hataya çok açıktır. Öyleyse kurucularda bu durumdan nasıl kaçınılabilinir?

Aslında bunun bir kaç yöntemi var. Örneğin yaratımsal (creational) kalıpları kullanmak. Ama nasıl bir çözüm önerilirse önerilsin yapılması gereken en temel şey, geçilen boolean parametreleri ortadan kaldırıp ya da en azından azaltıp, parametrenin rolünü metodun isminde ifade edecek şekilde kurgulanmış isimlere sahip, nesne oluşturan, gerekirse uzun isimli ama anlamlı metotlar yazmak. Eğer bu metotları ayrı bir sınıfta yazarsanız üretici metot (factory method) kalıbına varırsınız. Bu durumda bu sınıf şöyle olacaktır:

public class JTUserFactory{
	
	public JTUser produceVerifiedJTUser(...){ ... }

	public JTUser produceVerifiedJTUserUsingForm(Form form, ...){ ... }

	public JTUser produceVerifiedAndAuthorizedJTUserUsingForm(Form form, ...){ ... }

	...
}

(Üretici metot (factory method ) kalıbı için buraya bakabilirsiniz.)

Benzer ama bir başka çözüm, J. Bloch “Effective Java 2nd Ed.” isimli kitabının ilk maddesinde ifade edilmiştir. Burada tekli edilen şey, sınıfta kurucu kullanmak yerine statik factory metotlarının kullanılmasıdır. Yani yukarıdaki metotların statik olarak JTUser sınıfında olduğu durumdur. Ayrıca gerekirse bu metotları kullanmak için JTUser‘ın tüm kurucuları private yapılabilir.

Böyle bir yol izlendiğinde yukarıdaki kodumuz şu hale gelecektir:

public void authenticateUser(RegistrationForm registrationForm, 
                             HttpServletRequest request, 
                             Locale locale) throws JVTException {

   JVTUser user = JVTUser.createUnauthenticatedUser(registrationForm);

   if(authenticateUserUsingForm(registrationForm, locale, user)){
           
      authenticateFastRegisterUser(registrationForm, request);    
      
      mailSender.sendMail(user, locale);

      auditLogDao.insert(
          AuditLog.createAuditLogForUserAuthentication(user));
   }
}

Bu kodda, JTUser ve AuditLog sınıfları statik üretici metotlara sahip olacak şekilde kurgulandıklarından, nesnelerini oluşturmak createUnauthenticatedUser ya da createAuditLogForUserAuthentication gibi metotlarla çok daha rahat hale gelmiştir.

Kodun ilk halinin en berbat tarafı, sadece kötü yazılmış olması değildir. Çoğu zaman bu kodun sadece böyle yazılmış olmasına odaklanır esas problemi gözden kaçırırız. İlk haldeki gibi yazılmış karmaşık kodlar, copy-paste ile her yere dağılır. Her JTUser nesnesine ihtiyacı olan bu ve buna benzer kurucu çağrılarını, çağrıyı yapmak zor olduğundan, haklı olarak copy-paste ile alıp kullanma eğiliminde olur. Bu da bakımı çok zor bir kod yapısına götürür. Eğer bu çağrıyı yapmak için copy-paste’e başvuracak kişi, biraz akıllıca davranıp, yukarıda bahsedilen yollardan birisiyle, cut-paste kullanarak bu kodu iyileştirse (refactoring) idi çok güzel bir şey yapmış olurdu ve bu kod yapısı da iyileşerek büyürdü.

Burada kurucular üzerinden bir kod analizi yaparak nasıl daha temiz, nesne-merkezli ve bakımlanabilecek kod yazılabileceğini ele aldık. Ve yine temiz kod için iyileştirmeye (refactoring) ihtiyacımız oldu.

Rahat bakımlanabilir kodlar yazmak dileğiyle 🙂

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

]]>
http://www.javaturk.org/kod-analizi-kurucu-kullanimi/feed/ 2 6527
Tasarım Kalıpları – II: Neden Öğrenelim? http://www.javaturk.org/tasarim-kaliplarini-neden-ogrenelim/ Thu, 28 Jan 2016 21:56:38 +0000 http://www.javaturk.org/?p=6490 Bu yazıda tasarım kalıplarını neden öğrenmemiz gerektiğini ele alalım.

“Tasarım Kalıpları” tamlaması, kullanıldığında bir “üst perde” havası oluşturan bir kavrama karşılık geliyor. Sanki bu tamlamayı kullanan kişi birden “erenler”den oluveriyor. Kullanıldığında konuya ve özellikle de kullanana “ileri derecede karmaşıklık” ya da “sofistikasyon” atfediyor. Halbuki durum öyle değil, ama belli ki bu algı bizim cehaletimizden kaynaklanıyor.

Bir de bu konuda öğrenilmiş çaresizlik yaşıyor gibiyiz. Ben üç-beş defa bu konuyu öğrenmeye niyetlenmiş ve girişmiş ama her seferinde belli bir yerde bırakmak zorunda kalmış insanlarla tanıştım. Ülkemizdeki “İngilizce”nin durumu gibi 🙁 Sanki bilmek zorundaymışız, ciddi bir miktar zaman harcamışlığımız da var ama malesef henüz tam olarak bilmiyoruz gibi bir durumdayız. Her eğitimde ya da danışmanlıkta müşteri tarafında olan yazılımcı arkadaşlar bazen bir miktar uğraştıklarını göstermek, bazen kötü durumda olan kodlarının bu durumunu açıklamak ya da doğrudan benimle sohbet etmek vs. gibi sebep ve niyetlerle tasarım kalıpları tamlamasını ya da bazı tasarım kalıplarını telaffuz ederler.

Tasarım kalıpları etrafındaki oluşan bu buğulu havayı dağıtmak, başarılı bir öğrenim süreci için elzem görünüyor.

Tasarım kalıplarını kullanmadan program yazmaya başladığınızda ilk yapacağınız hata, program olarak ifade etmeye çalıştığınız iş süreci ya da problemindeki sorumlulukları roller olarak ayırt edememenizdir. Yani “bu problemin çözümünde hangi sorumluluklar var?” ve “bu sorumluluklar farklı nesnelere nasıl dağıtılmalı?” sorularının sorulması ve cevaplanması aslen bir tasarım faaliyetidir. Hatta tasarım daha doğrusu fonksiyonel tasarım faaliyeti temelde bu soruları açıklığa kavuşturmak, alternatif cevaplar verip bunları kıyaslayarak sonuca ulaşmadan ibarettir bile denebilir. Tasarım yapma niyetiniz yoksa ki bunu biz “zamanımız yok” diye ifade ederiz, zaten bu yazının geri kalanı anlamsız olur 🙂 Yok, doğru düzgün bir yapı ortaya çıkarmak için tasarıma niyetimiz varsa tasarıma vakit ayırırız ki yukarıdaki soruları sorarız ve tasarım kalıplarının yardımıyla vereceğimiz cevaplarla nesne modellerini oluştururuz.

Tasarım yapılmazsa dolayısıyla da tasarım kalıpları kullanılmazsa, istenildiği kadar en yeni teknolojiler kullanılsın ya da nesne-merkezli bir dille program yazılsın, sağlıklı bir nesne yapısı kurgulama ihtimali sıfıra yakındır. Çünkü, yukarıda bahsettiğim, sorumlulukları bulma ve nesnelere dağıtma işinin sağlıklı yapılmaması söz konusudur. Bu durumda da gidilecek yön, nesne-merkezli programlama değil, olsa olsa prosedürel programlama hatta daha da kötüsü, karman-çorman kod yığınıdır.

Örneğin, normalde tasarım yaparak ve tasarım şablonlarını kullanarak nesnelere ve üzerinde muhtemelen override edilmiş metotlara bölünecek bir davranışın, tek bir metot altında pek çok “if” kullanarak kodlandığı sıklıkla görülür. Bu durum ise olsa olsa “functional decomposition”dır ve başınızı gittikçe belaya sokan bir yaklaşımdır. Dolayısıyla tasarım kalıpları çoğu defa bize, normalde nesne-merkezli programlama dili kullanmamıza rağmen prosedürel anlayışla yazılım geliştirmeye düşmekten kaçınmamızı sağlar. Tam da bu yüzden pek çok refactoring yani kod iyileştirmesi tekniği, var olan karmaşık ve devasa hale gelmiş nesne ve metotları, farklı kalıpları kullanarak, ufak-tefek nesne ve metotlara dönüştürür. Tasarım kalıplarının bunu yaparken elinde tuttuğu temel teknik, yukarıda bahsettiğim iki sorudur: “bu problemin çözümünde hangi sorumluluklar var?” ve “bu sorumluluklar farklı nesnelere nasıl dağıtılmalı?” Zaten bu sorular sorulmadığından devasa sınıflara ve metotlara ulaşılmıştır.

Ben danışmanlıklarımda, özellikle kod kalitesini arttırıcı işlerimde bu durumlarla çok sık karşılaşıyorum. Tek yapacağım şey konuyu anladıktan sonra bu iki soruyu sormak. Tasarım kalıpları, bu iki sorunun cevabını ciddi oranda veriyorlar. Çünkü tasarım kalıpları hem bir yöntemdir hem de bir sorumluluk kataloğudur. Tasarım kalıpları yöntemdir çünkü bu iki soruyu sormanızı ve nasıl cevap vereceğinizi size öğretir. Tasarım kalıpları aynı zamanda bir sorumluluk kataloğudur, çünkü en basitinden en karmaşığına kadar, farklı sektördeki yazılımlarda bulunan en yaygın sorumlulukları ortaya koyar. Dahası tasarım kalıpları, bu sorumlulukları nasıl bulacağınızı ve bunları iç tutarlılığı yüksek (highly-cohesive) ve dış bağımlılığı düşük (lowly-coupled) nesne modellerine nasıl çevireceğimizi de bize gösterir.

Eğer tasarım faaliyeti, yazılım geliştirme sürecinizin bir parçası ise zaten yolunuz bir şekilde kalıplarla kesişiyor demektir. Yani sadece Gof’un 23 kalıbını kullanmakla kalmıyor, kendi iş alanınızda sıklıkla karşılaştığınız sorumluluk problemlerine özel kalıplar da geliştiriyorsunuz demektir.

Dolayısıyla tasarım kalıplarını şu amaçlarla öğrenmeliyiz:

  • Tekerleği yeniden keşfetmemek, var olan ispatlanmış çözümleri kullanmak: Tasarım kalıpları sıklıkla karşılaştığımız, yaygın sorumluluk bulma ve dağıtma problemlerini çözerek, tekrar kullanılabilen, faydası ispatlanmış modeller ortaya koyar.
  • Formal ve yaygın bir dil oluşturmak: Tasarım kalıpları, formal bir kalıp dili (pattern language) oluşturmaktadır. Bu kalıp dilinin en temel kavramı sorumluluktur. Dolayısıyla tasarım kalıpları zihnimize, “şu şey yapar, şunu alır şuna verir” gibisinden sokak ağzı bir konuşma yerine “kontrol nesnesi (controller), request ve response nesnelerini, ilgili üreticilerden (factory) alıp sunum (view) nesnesine geçer” şeklinde konuşmayı öğretir. Bu dilin yazılım geliştiriciler arasında yayılması, anlaşmayı kolaylaştıracak, ifade gücümüzü arttıracaktır.
  • Tasarıma uygun, yüksek soyutlama gücü kazandımak, detaylardan sıyrılıp, daha yüksek hedefler cinsinden düşünmek: Bu anlamda tasarım kalıpları daha iyi bir yazılım geliştirici hatta mühendisi olmanın en temel gerekliliklerindendir.

Zaman zaman karşılaşıyorum, “biz aslında bir miktar tasarım yapmıştık” şeklinde cümlelerle. Bırakın kalıbı sistemde hiç arayüz yok, hiç bir nesne hiyerarşisi yok, devasa sınıflar ve metotlar var, nesneler arası ilişkiler karmakarışık, kim neyi biliyor belli değil, peki tasarım nerede? Yukarıda anlattığım gibi tasarım yapılacaksa o iki sorudur üzerinde düşünülmesi ve çözülmesi gereken şey. Ve yolunuz bir şekilde tasarım kalıplarıyla kesişir.

Tasarım kalıplarını bilmiyorsanız, tasarım da yapamazsınız.

Bol tasarımlı günler dilerim 🙂

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

]]>
6490
Staj – 2016 http://www.javaturk.org/staj-2016/ http://www.javaturk.org/staj-2016/#comments Tue, 29 Dec 2015 09:52:43 +0000 http://www.javaturk.org/?p=6473 Sevgili JavaTürk takipçileri,

Yazılım Mühendisliği ve teknolojik olarak da Java alanlarında yaptığım çalışmalarda bana yardımcı olacak1 ya da 2 tane stajyer arkadaşa ihtiyacım var. Stajyer arkadaşların sorumlulukları şunları içerecektir:

  • YM ve Java başta olmak üzere değişik konularda AR-GE faaliyetlerinde bulunmak,
  • Yürüttüğüm danışmanlık ve eğitim faaliyetlerinde bir miktar kırtasiye de dahil olmak üzere yardımcı olmak.

Staj çalışmalarının bir kısmını kendi yerinizden kalkmadan yapabileceğiniz gibi ofisimizde de yapabilirsiniz.

Aday arkadaşların öncelikle yaptıkları işi çok sevmeleri, tutkulu olmaları şart. Temel konulardaki bilgileri de sağlam olmalı. Yani analitik ve matematiksel düşünme yetenekleri yanında yazılım ve Java dili ile ilgili temel bilgileri haiz olmalılar. Algoritmik düşünce yetkinliklerini kazanmış, nesne-merkezli programlama konusunda temel yapıları özümsemiş ve tercihen Java SE kullanan ve kendini daha da geliştirmek isteyen adayları tercih ederim. Bu anlamda şart olmamakla birlikte, daha yukarı sınıflardaki arkadaşlarla çalışmamız sanırım daha rahat olacaktır. İlgisini, tutkusunu ve bilgisini gösteren herkese kapım açık olmakla birlikte…

İlgilenlerin bana buradan CVlerini paylaşarak ulaşmaları yeterli olacaktır. Lütfen CVlerinizi göndermeden önce bir daha kontrol edin, CV’de yazana değer verdiğimi ve doğru olduğunu düşünmek dışında bir seçeneği göz önüne almadığımı da bilin. Dolayısıyla Cvnizi göndermeden önce şunlara son bir daha göz atın:

  • Mahrem bilgilerinizi CVnize yazmayın. Evli olup olmadığınız, değilseniz kız-erkek arkadaşınızın olup olmadığıyla ilgilenmiyorum 🙂
  • 3 senelik okul hayatına ve 0 günlük profesyonel çalışma tecrübesine rağmen “4 senelik tecrübe” yazmayın,
  • CVnizi teknoloji çorbasına çevirmeyin. “25 seneye sığacak tecrübeyi ben 2 senede elde ettim” demeye getirmeyin. Dolayısıyla seminerine gittiğiniz teknolojiyi “biliyorum” diye yazmayın. Arzu ederseniz bu blogdaki “bilmek” ile ilgili yazılarımı okuyun 🙂
  • CV yazmak sizin kendinizi tanımınızı sağlayabilir. Dolayısıyla “ben zaten XXX’i biliyorum” demek yerine “XXX’i daha iyi öğrenmek istiyorum” gibi cümle kurmaya CV yazarken başlayabilirsiniz. Ben de açıkçası bunu tercih ederim
  • MS Office ürünlerini teknoloji kısmında sıralamayın.
  • İngilizce, bu staj için önemli. “Okuma: 10, Dinleme: 10, Konuşma: 9” şeklinde gelen CV sahiplerinin “Hi, I am calling you from Selsoft regarding your intern application. How are you doing today sir/ma’m?” şeklinde başlayan bir telefon alabileceklerini göz önüne almaları gereklidir.

Bu ülkedeki bir üniversite öğrencisinin neyi ne kadar bilebileceğini fena bir şekilde farkındayım. Beni kandırmak yerine şaşırtmaya çalışın. Bildiklerinizle ilgileniyorum fikir sahibi olduklarınızla değil! Yapabildiklerinizle ilgileniyorum bildiklerinizle değil! Yaptıklarınızla ilgileniyorum yapabildiklerinizle değil!

Ayrıca bu kadar da soğuk bir adam değilim, geyik ve keyifli sohbeti çok severim 🙂

CVlerinizi bekliyorum.

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

]]>
http://www.javaturk.org/staj-2016/feed/ 14 6473