Scala’da Class ve Object

Herkese merhabalar!

Bu yazımda sizlere Scala’daki class ve object yapılarını, aralarındaki farkları ve bunların Java’dan farklarını anlatmaya çalışacağım. Bir önceki yazımda IDEA ile geliştirme yapmaktan bahsettiğim için artık yazılarımı projeler halinde IDEA üzerinde geliştireceğim. Ayrıca bu projeleri Github’daki https://github.com/makiftutuncu/ScalaBlogOrnekleri depoma ekleyeceğim.

Başlamadan önce IDEA ile ClassVeObject isimli bir Scala projesi yarattım. com.mehmetakiftutuncu.classveobject paket yapısını oluşturdum. Son olarak içinde boş bir main metodu olan Main.scala dosyasını oluşturdum.

Haydi başlayalım!

Scala’da Class

Scala’da class tıpkı Java’daki gibi bir sınıfı ve o sınıfın türünü temsil eder. class özel kelimesi ile oluşturulur. Java’dan farklı olarak içine yazılacağı dosya ile aynı isme sahip olması şart değildir. Ayrıca bir Scala dosyası içine en dışarıda sadece tek bir class yazmak da şart değildir. Bir Scala dosyası içinde birden çok class (hatta object ve trait) yazılabilir.

Şimdi Java ile karşılaştırmalı bir örnek yapalım. Burada bahsettiğim dosyaları isimlerine tıklayarak Github deposunda görüntüleyebilirsiniz.

JavaSinifi1.java dosyasına bir Java sınıfı, ScalaSinifi1.scala dosyasına da onun Scala’daki birebir karşılığını yazdım. Bu örnek aynı zamanda projenizde Scala ile birlikte Java da kullanabileceğinizi gösteriyor. 🙂 Şimdi ScalaSinifi1 sınıfını inceleyelim.

Buradaki ilk fark, public olan JavaSinifi1 sınıfının aynısı olan ScalaSinifi1 sınıfının tanımında public kelimesinin olmaması. Bunun basit bir nedeni var. Scala’da aksi söylenmedikçe her şey public olarak tanımlanır. Scala’nın gereksiz kelimeleri atmasına bir örnek daha. 🙂

Daha sonra iki class da birer private field (örnek değişkeni) tanımlıyor.  JavaSinifi1 bu field’ın ilk değerini varsayılan (boş) constructor (yapılandırıcı) metodunda atıyor. ScalaSinifi1 sınıfında ise durum biraz daha farklı. Scala’da bir class’ın gövdesinde metod haricindeki her şey aslında o class’ın varsayılan constructor’ını oluşturuyor. Yani ScalaSinifi1.scala dosyasındaki 7. satır aslında bu sınıfın varsayılan constructer’ında. Bu yüzden isim field’ının ilk değerini doğrudan atıyoruz. Ayrıca burada isim field’ının private olmasını özellikle belirttiğimizi görüyorsunuz.

Gelelim parametre alan ek constructor’a. Java’da sınıfın adına sahip bir metod gibi tanımladığımız ek constructor’ı, Scala’da sınıfın adı yerine this adıyla tanımlıyoruz. Scala’daki ek constructor’ların şöyle bir farkı var. Her ek constructor ilk önce this() diyerek varsayılan constructor’ı çağırmak zorunda. Yoksa hata alırsınız. Bu örnekte de isim field’ına önce boş bir String, sonra da constructor’a gönderilen değer atanıyor.

Buradaki ScalaSinifi1 sınıfını Java’daki örnekle birebir eşleşmesi için kasıtlı olarak böyle yazdım. Şimdi başka bir örnekle Scala’ya daha uygun ve daha iyi nasıl yazabileceğimizi görelim.

Burada JavaSinifi2.java ile birebir aynı olan ScalaSinifi2.scala sınıfını görebilirsiniz. Gördüğünüz gibi Scala hali çok daha kısa ve basit.

Scala’da class’a ait public field’ları birer metod parametresi yazıyormuş gibi parantezler içine yazabiliyoruz. Bununla birlikte varsayılan değer atamalarını da kullanınca basit bir class tanımı tek satıra bile indirgenebiliyor. Aynı şeyi Java’da yapmak için fazladan 2 constructor yazmak zorunda kaldığımıza dikkat edin. 🙂

Son bir not olarak; bu sınıfların içinde birer de metod olsun istedim ve toString metodlarını tanımladım. Java’da @Override işaretlemesini kullanmamız gerekiyorken Scala’da override özel kelimesini kullanıyoruz.

Scala’da Object

Yazılım geliştirirken sık sık ihtiyaç duyduğumuz singleton pattern denilen bir kavram var. Bir nesneden bellekte sadece bir örnek olmasını sağlıyor. Java’da bunu sağlamak için singleton olmasını istediğimiz class’ın dışarıdan erişilebilen hiçbir constructor’ı olmaması, static şekilde tanımlanmış kendi türünden bir field’ı olması ve bu field’ı gerektiğinde geri döndüren dışarıya açık bir metodunun olması gerekiyor. Scala’da singleton yazmak istediğimizde tek bir kelime kullanmamız yeterli; object. 🙂 Scala’daki object kelimesi ile tıpkı bir class tanımlar gibi singleton’lar tanımlayabiliyoruz. Bir örnekle görelim.

Burada JavaSingleton.java ile ScalaSingleton.scala arasındaki farkı görebiliyorsunuz. ScalaSingleton denilen tür, tanımı gereği bir singleton ve bellekte sadece bir örneği olacak. Object içinde tanımlanan metodlar, singleton class’a ait normal metodlar veya herhangi bir class’a ait static metodlar gibi çalışıyor. Yani, Main.scala içindeki örnekte de görebileceğiniz gibi, sınıfın bir örneği yerine doğrudan sınıfın adı üzerinden çağrılabiliyor.

Scala’da Companion (Yardımcı) Object

Object ile yapabileceğiniz tek şey kolayca singleton oluşturmak değil. Eğer class’ınızla aynı isimde bir de object’iniz varsa bu object o class’ın companion (yardımcı) object‘i oluyor. Eğer bir class’ın companion object’i varsa o tür için hem class’ın hem de object’in özelliklerini kullanabilmeye başlıyorsunuz. Bir örnek üzerinden görelim.

JavaDunyasi.java dosyasında static tanımlanmış sabit dunyaAdi, static olmayan sabit surum, sürümü 1 olarak belirleyen varsayılan constructor, sürümü dışarıdan alan ek constructor, static tanımlanmış selam() metodu ve toString tanımlamasını görüyoruz. Şimdi Scala tarafına gelelim.

ScalaDunyasi.scala dosyasında bir önceki örnekteki gibi bir class tanımlaması görüyoruz. 6, 7 ve 8. satırlar bize surum sabitini, ek constructor’a olan ihtiyacı ve toString tanımlamasını sağlıyor. Şimdi sonrasında yazdığımız companion object’i inceleyelim.

11. satırda val olarak tanımladığımız için sabit olan, bir object içinde tanımladığımız için de static olan dunyaAdi değerini görüyoruz. Bu değere 7. satırda static olarak erişildiğine dikkat edin.

13 ve 17. satırlarda tanımlanan metodlar özel isimli metodlar. Scala’da bir tür adından sonra açılan ve kapanan parantezler () yazmak aslında o türün companion object’indeki apply metodunu çağırmak demek. Burada işte bu özellikten faydalanarak kendimize ek constructor’lar yazdık. Dikkat ederseniz tanımladığımız apply() metodları bizim tanımladığımız ScalaDunyasi türünden değerler döndürüyorlar. Ayrıca Main.scala içindeki 33 ve 34. satırlara dikkat ederseniz apply() metodları sayesinde yeni bir nesne oluştururken new kelimesini de kullanmak zorunda kalmadık. Aslında yaptığımız şey ScalaDunyasi object’indeki apply() metodunu çağırmak. Bu metodların gövdelerinde de yeni birer ScalaDunyasi nesnesi oluşturuyoruz. Böylece bu metodlar constructor gibi çalışıyorlar.

22. satırda da selam() metodunu görüyoruz. Bu metod bir önceki singleton örneğimizdekiyle aynı mantıkta çalışıyor.

Gördüğünüz gibi class’ı ve object’i bir arada kullanarak daha az kodla daha gelişmiş işler yapabiliyoruz. Unutmayın, bir object’in companion object olabilmesi için class’ı ile aynı isimde olması gerekiyor. Ayrıca ScalaDunyasi.scala dosyasında bir dosya içinde birden fazla class ve/veya object yazılabileceğinin de örneğini görmüş olduk. 🙂

Sonuç

Bu yazımda sizlere Scala’nın class ve object yapılarını, companion object’i ve bunların Java’daki hallerinden farklarını örneklerle anlatmaya çalıştım. Tüm terimleri Türkçeleştir(e)medim çünkü o zaman yazdıklarım çok daha anlaşılmaz bir hal alıyor. 🙂

Bu yazıdaki projeyi Github’daki https://github.com/makiftutuncu/ScalaBlogOrnekleri depomda bulabilirsiniz.

İnşallah anlaşılır olmuştur. Sonraki yazılarda görüşmek üzere.

Hoşça kalın!

IntelliJ IDEA Üzerinde Scala Geliştirmek

Herkese merhaba!

Yazılarımda temel konulardan biraz daha gelişmiş konulara doğru geçmeye başladığımdan, bundan sonraki yazılarımda anlatacaklarımı bir geliştirme ortamı (IDE) üzerinde geliştirerek anlatmaya karar verdim. Bu yüzden bu yazımda sizlere işimde ve kişisel hayatımda kullandığım IntelliJ IDEA’yı anlatacağım.

Haydi başlayalım!

IntelliJ IDEA’yı Yüklemek

IntelliJ IDEA oldukça gelişmiş bir geliştirme ortamı. Windows’ta, Linux’ta ve OS X’te çalışabiliyor. Tüm bu platformlarda kolayca yüklenebiliyor. Ücretsiz olan Community Edition sürümü Scala geliştirmek için yeterli olacaktır. Geliştirme yapacağınız platforma uygun IDEA’yı aşağıdaki bağlantıdan indirip yükleyebilirsiniz.

https://www.jetbrains.com/idea/download/

Ben şu an OS X için IntelliJ IDEA 15 Community Edition sürümünü kullanıyorum.

Yeni Bir Scala Projesi Oluşturmak

IDEA’yı başlattığınızda sizi; yeni bir proje oluşturabileceğiniz, kodlarına sahip olduğunuz bir projeyi IDEA’ya aktarabileceğiniz, var olan bir IDEA projenizi açabileceğiniz ve hatta bir sürüm kontrol sisteminden bir projeyi çekebileceğiniz buna benzer bir ekran karşılayacak.

Sol tarafta da daha önceden IDEA’da açmış olduğunuz projeleri görebiliyorsunuz. Şimdi “Create New Project” diyerek yeni bir proje oluşturalım.

Bu ekranda IDEA’nın desteklediği diğer proje türlerini de görüyorsunuz. Scala‘yı seçelim ve Next diyerek devam edelim. Bu bize boş bir Scala projesi oluşturacak.

Bu ekranda projemizin adını, diskteki konumunu, kullanacağı Java ve Scala SDK seviyelerini belirliyoruz. Eğer kurulumlarınızda bir sorun yoksa IDEA Java ve Scala SDK’larınızı tanımalı. Eğer tanıyamadıysa yanlarındaki butonlar ile Java’nın ve Scala’nın SDK’larının yüklü olduğu yerleri IDEA’ya göstermeniz gerekebilir.

Ekranın alt kısmında da IDEA’nın projemiz için oluşturacağı modüle ilişkin ayarları belirtebiliyoruz. Bu ayarları olduğu gibi bırakmak çoğu zaman yeterli olacak. Modüllerden ve birden fazla modülle çalışmaktan, özellikle de Play Framework ile web uygulamaları geliştirmeyi anlatırken bahsedeceğim. Finish diyerek devam edelim ve projemizi oluşturalım.

Projemiz oluşturuldu. Soldaki Project penceresinde projemizin yapısını ve içindeki dosyaları görüyorsunuz.

Buradaki mavi renkli src dizini önemli. IDEA varsayılan olarak bu dizini kaynak kodların bulunacağı yer olarak işaretledi. Mavi renk bu yüzden. Tabi ki şu an içi boş. Hemen bir paket oluşturalım ve içine uygulamamızı başlatacak main metodu olan bir obje oluşturalım.

src dizinine sağ tıklayıp New altındaki Package seçeneğini seçiyoruz ve paket(ler)imizin adını yazıyoruz.

Daha sonra bu paketin içine bir obje oluşturacağız. Bu sefer pakete sağ tıklayıp New altındaki Scala Class seçeneğini seçiyoruz ve objemize adını veriyoruz.

Burada önemli bir nokta var. Amacımız main metodu yazmak olduğu için oluşturacağımız Class’ın bir Object olması gerekiyor. Scala’da main metodları Object‘ler içinde yer alır. Class ve Object ayrımına bir sonraki yazımda detaylıca değineceğim. Bu anlatacaklarımla beraber yazacaklarımız projeler haline geleceğinden, önce IDEA’yı kullanarak Scala geliştirmeyi anlatmak istedim. Böylece birden fazla dosyadan ve sınıftan oluşan projeleri daha kolay geliştirebileceğiz.

Yeni Object’imiz oluşturuldu. Şimdi de main metodumuzu ekleyelim. Burada IDEA’nın güzelliklerini göstermek adına bazı işleri IDEA’ya yaptıracağım. 🙂

Gördüğünüz gibi “main“ yazdığımızda IDEA bir main metodu oluşturmak istiyor olduğumuzu düşünüp hazır kod parçalarından bir öneride bulundu. Önerilen seçeneği Enter‘a basarak seçelim.

IDEA main metodunu bizim için oluşturdu bile. Şimdi de içine bir önceki yazımdaki örneğimizin kodunu yazalım. Kodu yazarken IDEA’nın bize nasıl yardımcı olduğunu da göreceğiz.

Gördüğünüz gibi IDEA bir metod çağrısı yapacağımız zaman o metodun beklediği parametreleri bize gösteriyor ve parametreleri yazdıkça bu uyarı güncelleniyor. Bu özellik, özellikle çok parametresi olan sınıflarla ve metodlarla çalışırken çok yardımcı oluyor. Ben şahsen çok seviyorum. 🙂

Bir başka başarılı özellik de kod yardımı. Gördüğünüz gibi daha yazarken IDEA bize erişebileceğimiz değerleri ve metodları akıllı bir şekilde listeliyor.

Bunlar ve bunlar gibi başka birçok özelliği ile IntelliJ IDEA oldukça başarılı bir IDE. Siz de kullandıkça göreceksiniz ki IDEA ile Scala geliştirmek çok daha kolay ve verimli hale geliyor. Geliştirme yaptığınız platforma göre IDEA’nın klavye kısayollarını öğrenmenizde de büyük fayda var çünkü IDEA kısayollarıyla, projeler büyüdükçe daha da zor hale gelen kod içinde dolaşmak, bir şeyler aramak, bir şeyleri taşımak/yeniden isimlendirmek gibi birçok işi kolayca erişilebilir hale getiriyor.

Haydi artık uygulamamızı çalıştıralım.

Scala Uygulamasını Çalıştırmak

IDEA’da bir uygulamayı çalıştırmak için çalıştırma ayarlarına ihtiyacınız var. Neyse ki bunları oluşturmak oldukça basit.

IDEA’nın Run menüsünden Run seçeneğini seçiyoruz. IDEA bize henüz hiç çalıştırma ayarımız (Run Configuration) olmadığı için hangi modülü çalıştırmak istediğimiz soracak.

Modülümüzü seçiyoruz ve IDEA bizim için bu modülü çalıştıracak bir çalıştırma ayarı oluşturuyor. Daha sonra da uygulamamızı çalıştıracak.

Uygulamamız çalıştı ve ekranın altında açılan bir pencerede çalışmanın sonucunu görüyoruz.

Artık elimizde bir çalıştırma ayarı olduğu için araç çubuğundaki çalıştır butonu ile uygulamamızı doğrudan çalıştırabileceğiz. Butonun sol tarafında da şu anda seçili olan çalıştırma ayarını görüyorsunuz.

Şimdi kodumuzu biraz bozalım ve hata aldığımızı görelim.

Gördüğünüz gibi IDEA henüz derleme veya çalıştırma yapmadan bize hatamızı gösteriyor. Şimdi hatalı kodumuzu çalıştırmayı deneyelim.

IDEA kodumuz değiştiği için çalıştırmadan önce kodu derlemeyi deneyecek. Derleme sırasında hata alınca da bize hataları gösterecek.

Sonuç

Bu yazımda sizlere IntelliJ IDEA’dan ve Scala geliştirirken IDEA’yı kullanmaktan bahsetmeye çalıştım. Önceki yazılarıma göre çok daha fazla ekran görüntüsü kullanmam gerekti. İnşallah ekran görüntüleri daha iyi anlaşılmasına yardımı olmuştur.

Bu yazımdaki projeyi ve bundan sonraki yazılarımda oluşturacağım projeleri Github hesabımdaki bir depoya gönderiyor olacağım. Yazılarımda kod parçalarını yine Gist’ler halinde ekleyeceğim ama projelerin bütün halleri Github’da olacak. Depoya aşağıdaki bağlantıdan ulaşabilirsiniz.

https://github.com/makiftutuncu/ScalaBlogOrnekleri

Gelecek yazılarda görüşmek üzere. Hoşça kalın!

Scala’da Döngü İfadeleri

Herkese merhaba!

Bir önceki yazımda programlamanın en temel konularından olan koşul ifadelerinden bahsetmiştim. Bu yazımda da ikinci bir temel kavram olan döngülerden ve bunların Scala’daki işleyişlerinden bahsedeceğim. Scala’da while ve for döngüleri olmak üzere 2 çeşit döngü var.

Haydi başlayalım!

while Döngüsü

Bu döngüler while özel kelimesi, sonrasında bir koşul ve sonrasında bu koşul sağlandığı sürece tekrar tekrar çalıştırılacak olan ifade(ler)den oluşan yapılardır. Yapısı Java’daki ile aynıdır. Örneklere bakalım.

	// Java
	int i = 1;
	while (i <= 10) {
	System.out.println(i + "!");
	i++;
	}
	System.out.println("Önüm, arkam, sağım, solum, sobe!");
	// Scala
	var i = 1
	while (i <= 10) {
	println(i + "!")
	i += 1
	}
	println("Önüm, arkam, sağım, solum, sobe!")
	// Romantik Scala geliştiricisi
	while (true) {
	println("Seni seviyorum!")
	}

view raw

ScalaDonguIfadeleri1.scala

hosted with ❤ by GitHub

Yukarıdaki örnekte saklambaç oyununda ebe olan bir arkadaşın kodlarını görüyorsunuz. 🙂 Gördüğünüz gibi Scala’daki while döngülerinin Java’dakinden pek bir farkı yok. Bu örnekte koşulun zaman içinde değişmesi gerektiği için var kullandık. Java’daki “i++” ifadesi yerine Scala’da “i += 1″ ifadesini kullandığımızı görüyorsunuz. Scala’da ++ ve — işlemleri yok. Çünkü Scala fonksiyonel programlamayı öne çıkarıyor ve bir şeylerin değerini değiştirmek fonksiyonel programlama felsefesine aykırı. Benzer şekilde, Java’da bir döngüden break özel kelimesiyle çıkabiliyorken Scala’da bunu da yapamıyorsunuz. Uygulamanın akışını bu şekilde değiştirmek de fonksiyonel programlamaya ve Scala’ya göre hoş bir davranış değil. 🙂 Son olarak da bir sonsuz döngü görüyorsunuz. Java ile aralarında bir fark yok. Yalnız kullanırken dikkatli olmakta fayda var çünkü az önce belirttiğim gibi break kullanamıyorsunuz. Bunu çözmenin birkaç yolu var ama bence en güzeli while döngüsü kullanmaktan kaçınmak. Eğer gerçekten while kullanmanız ve döngüyü bir noktada kesmeniz gerekiyorsa bunu daha sonra detaylıca anlatabilirim.

for Döngüsü

Gelelim for döngüsüne. Scala’da for döngüsü oldukça gelişmiş özelliklere sahip. Hatta aslında sadece bir döngü değil. Scala’da basit bir döngüden daha fazlasını yapan for’lar için “for döngüsü” yerine “for comprehension“ yani “for anlaması/kavraması” da deniliyor. Şimdi en temel halinden daha gelişmiş özelliklerine doğru örneklere bakalım.

	// Java
	for (int i = 1; i <= 10; i++) {
	System.out.println(i + "!");
	}
	System.out.println("Önüm, arkam, sağım, solum, sobe!");
	// Scala
	for (i <- 1 to 5) println(i + "!")
	for (j <- 6 until 11) {
	println(j + "!")
	}
	println("Önüm, arkam, sağım, solum, sobe!")

view raw

ScalaDonguIfadeleri2.scala

hosted with ❤ by GitHub

Yukarıdaki örnekte Java kısmında çok basit bir for döngüsü görüyorsunuz. Bir değişken tanımlayıp değerini 0 yapıyor, belirli bir koşul tanımlıyor ve döngünün her aşamasında bu değişkenin değerini artırıyor. Şimdi aynı döngünün/döngülerin Scala’daki karşılığına bakalım.

8. ve 9. satırlardaki döngüler aslında fonksiyonel döngüler. Bir değişken tanımlayıp bunun değerini değiştirerek çalışmıyorlar. to ve until kelimelerine dikkat edin. to kelimesi ile 1’den 5’e kadar sayı aralığı üretiyoruz. Aslında buradaki to, 1 değeri üzerinde çağrılan bir metod. Bu tür metod çağrılarına ileride değineceğim. Böylece “1 to 5” ifadesi scala.collection.immutable.Range.Inclusive türünde, içinde 1’den 5’e kadar (5 dahil) sayılar olan bir Range, yani aralık, oluşturuyor. Daha sonra da for döngüsü, bu Range üzerindeki her eleman için, elemanlara i ismiyle erişecek şekilde çalışıyor. Burada üzerinde döndüğümüz Range içinde Int türünde sayılar olduğundan, i‘nin türü, tür çıkarımı sonucunda Int olarak belirleniyor. Döngünün gövdesi tek bir ifadeden oluşacaksa 8. satırda görebileceğiniz gibi süslü parantezleri yazmayabiliyoruz ama bu şekilde yazım pek tavsiye edilmiyor. Süslü parantezleri hep kullanmakta fayda var.

9. satırda da to yerine until kullanımına örnek olması için yazdığım başka bir döngü var. 10’a kadar saymaya kaldığımız yerden devam ediyoruz. Bu sefer (önceki döngüde 5’i dahil ettiğimiz için) 6 üzerinde until‘i çağırarak 6’dan 11’e kadar (11 hariç), scala.collection.immutable.Range türünde bir Range üretiyoruz. Bu seferki döngümüzde her elemana j ismiyle ulaşacağız.

Buradaki Scala for döngüleri aslında Java’daki gelişmiş for döngüleri gibi bir koleksiyon üzerindeki her bir elemanı ziyaret ederek çalışıyor ve her elemana ulaşacağımız bir değişken adı tanımlıyoruz. Bunu yaparken kullandığımız <- (küçüktür ve kısa çizgi) işaretine dikkat edin. 🙂

Yukarıdaki örnek basit bir sayma işlemine karşılık geliyordu. Java’da bunun için de koşullar yazıyor olsak da Scala’da to ve until ifadeleriyle saymayı kolayca yapabildiğimizi gördük. Şimdi biraz daha ilerleyelim ve döngümüze farklı koşullar ekleyelim.

	// Java
	for (int i = 1; i <= 20; i += 2) {
	for (j = i; j <= i * 2 && j < 14; j++) {
	System.out.print("[" + i + ", " + j + "] ");
	}
	}
	// Scala
	for {
	i <- 1 to 20 by 2
	j <- i to (i * 2) if j < 14
	} {
	print("[" + i + ", " + j + "] ")
	}

view raw

ScalaDonguIfadeleri3.scala

hosted with ❤ by GitHub

Burada daha karmaşık koşulları ve ilerleme ifadeleri olan, değerleri birbiriyle bağlantılı olan iç içe 2 döngü yazdık. Şimdi Scala’daki halini incelemeye başlayalım.

Scala birden fazla boyutta for döngüleri yazacağımız zaman for kelimesinden sonraki parantezlerin yerini süslü parantezler alıyor. Her bir döngüyü ayrı bir satıra gelecek şekilde yazıyoruz.

Buradaki örnekte 10. satırda 1 to 20 ifadesini biliyoruz ama bu sefer bir ekleme var. “1 to 20 by 2” ifadesi 1’den 20’ye kadar Range oluşturuyor ama ikişer artırarak oluşturuyor. Yani sonuçta (1, 3, 5, …, 17, 19) şeklinde bir Range oluşuyor. Bunun Java örneğindeki i += 2 ifadesine karşılık geldiğini görebilirsiniz.

11. satırda da ilk döngümüzün içindeki ikinci döngümüzü tanımlıyoruz. Burada j‘ler, i‘nin o anki değerinden, (i * 2)‘ye kadar ilerleyecek ama sonrasında gelen j < 14 koşulunu sağladığı sürece. Burada gördüğünüz gibi, for döngüsünde döngüyü sadece belirli koşullarda ilerleyecek şekilde yazabiliyoruz. Bunun için de bir koşul yazmak için en mantıklı olan şeyi, yani if kelimesini kullanıyoruz. if’ten sonra parantez kullanma zorunluluğu yok. (match … case ifadelerindeki koşulları hatırlayın.) Bu döngü çalıştığında aşağıdaki sonucu alacağız.

Gördüğünüz gibi i değerleri ikişer artıyor. j değerleri de 14’ten her zaman küçük. Bu koşul bozulduğu anda döngünün durduğunu görüyorsunuz. Yukarıda break olmamasından ve while kullanmaktan mümkün olduğunca kaçınmak gerektiğinden bahsetmiştim. Gördüğünüz gibi sorununuzu buna benzer for döngüleri ile büyük ihtimalle çözebilirsiniz. 🙂

Şimdi son bir örnekle Java’daki gelişmiş for döngülerine benzer bir döngü yazalım. Ama sırf yapabildiğimiz için bu döngü bir değer de üretsin. (if bloğundan değer üretmeyi hatırlayın.)

	// Java
	String[] isimler = new String[] {"Ali", "Veli", "Ahmet", "Hüseyin", "Akif"};
	String[] secilenIsimler = new String[isimler.length];
	int i = 0;
	for (String isim : isimler) {
	if (isim.startsWith("A") && isim.length > 3) {
	System.out.println("Seçilen isim: " + isim);
	secilenİsimler[i] = isim;
	i++;
	}
	}
	// Scala
	val isimler: Array[String] = Array("Ali", "Veli", "Ahmet", "Hüseyin", "Akif")
	val secilenIsimler: Array[String] = for (isim <- isimler if isim.startsWith("A") && isim.length > 3) yield {
	println("Seçilen isim: " + isim)
	isim
	}

view raw

ScalaDonguIfadeleri4.scala

hosted with ❤ by GitHub

Buradaki örneğimiz tanımlanmış bazı isimlerden A harfi ile başlayan ve 3 karakterden uzun olan isimleri buluyor. Java’daki örnekte, 6. satırda gördüğünüz gibi bir koleksiyon üzerinde gelişmiş for döngüsü kullanıyoruz. Ayrı bir Array’de de sonucu saklıyoruz. Şimdi Scala’daki örneğe bakalım.

Scala’da bir koleksiyon üzerinde for döngüsü yapmak yukarıdaki örneklerle aynı. Bir değişken ismi veriyoruz, <- işaretini kullanıyoruz ve koleksiyonu yazıyoruz. 15. satırda bir Array tanımlanışı görüyorsunuz. Koleksiyonları anlatacağım yazımda daha detaylı bahsedeceğim için şu an bunun detaylarına girmiyorum. Şimdi 17. satırda başlayan döngüye bakalım.

17. satır bir val tanımlamasıyla başlıyor. Değer olarak da doğrudan döngünün kendisini yazdık. Buradaki döngümüz (tıpkı daha önce if bloklarında anlattığım gibi) çalıştırılıp bir değer üretiyor. Bir for döngüsünün değer üretmesi için gövdesi yerine yield kelimesini kullanıyoruz. Burada isimler isimli Array’imiz üzerinde isim diye adlandırdığımız bir değişkenle dönüyoruz. Koşullarımızı da doğrudan döngüye ekleyebildiğimizi görüyorsunuz. Bu sayede eğer o anki eleman koşula uymuyorsa atlanacak ve üretilen değere dahil edilmeyecek. yield kelimesinden sonra gelen blokta da hangi isim olduğu yazıyoruz ve ismi geri dönüyoruz. Burada bir Array[String] üzerinde döndüğümüz için döngüde tanımladığımız isim değişkeninin türü String. yield ifadesininden de geriye isim, yani String türünden bir değer döndürdüğümüz için döngünün tamamı Array[String] değeri üretmiş oluyor. Bu değeri de secilenIsimler val’ına atıyoruz.

for döngüleriyle ilgili başka örnekler de yazıp, deneyerek alıştırma yapmanızı tavsiye ederim. Özellikle özel koşulları olan for döngüleri ve yield ile değer üreten döngüler, tam anlamıyla hakim olduğunuzda gerçekten güçlü araçlar. 🙂

Sonuç

Bu yazımda sizlere Scala’da döngü ifadelerinden bahsetmeye çalıştım. Farklı yönlerini görebilmeniz adına Java’daki halleriyle karşılaştırmalar da yaptım. İnşallah anlaşılır olmuştur.

Görüşmek üzere. Hoşça kalın!

Scala’da Değişkenler (var), Değerler (val) ve Metodlar (def)

Merhabalar! Bundan sonraki yazılarımda daha çok ve somut örnekler ve karşılaştırmalar üzerinden giderek temel birçok kavrama değineceğim. Böylece Scala ile daha çok ve anlamlı uygulamalar geliştirmeye başlayabileceğiz. Bu yazımda en programlamadaki en temel kavramlardan biri olan değişkenlerden, Scala’da daha sık kullanılan değişmez değerlerden ve metodlardan bahsedeceğim.

Haydi başlayalım!

1. Değerler (val) ve Değişkenler (var)

Uygulama geliştirirken bir değeri veya nesneyi saklamak ve isimlendirmek için değişkenler kullanırız. Hatta bazen bu isimlendirdiğimiz şeyin bir daha değiştirilmemesini de isteyebiliriz. Scala’da bu işler için 2 özel kelime var.

1.1. Değişken (var)

Değerini sonradan değiştirebileceğiniz bir değer veya nesne oluşturmak için var özel kelimesini (İngilizce değişken anlamına gelen variable‘ın kısa hali) kullanabilirsiniz. Aşağıdaki birkaç değişik örnek yazdım.

	var sayi: Int = 6
	var metin = "Sayı çift mi?"
	var ciftMi: Boolean = _
	println("Sayı: " + sayi)
	println(metin + " " + ciftMi)
	ciftMi = sayi % 2 == 0
	println("Tekrar bak.")
	println(metin + " " + ciftMi)

view raw

ScalaTemelKavramlar.scala

hosted with ❤ by GitHub

İlk satırda sayi adında Int türünde, değeri 6 olan bir değişken oluşturuyoruz. Burası açık.

İkinci satırda adı metin olan, türünü belirtmediğimiz bir değişken yaratıyoruz. Böylece Scala String olduğunu çıkarım yaparak bulacak.

Üçüncü satırda ise yarattığımızda değerini belirtmediğimiz ciftMi adında Boolean türünde bir değişken oluşturuyoruz. Bir değişkeni değerini vermeden yaratmak için Java’da ve diğer dillerde sadece adını ve türünü yazmak yeterliyken, Scala’da değerinin sonradan verileceğini belirtmemiz gerekiyor. Bunu da _ (alt tire) yer tutucu (placeholder) karakteri ile sağlıyoruz. Değerini vermeden değişken yaratacağımız zaman – Scala değeri bilmeden tür çıkarımı yapamayacağı için – türü belirtmemiz gerekiyor. Değerini belirtmeden değişken yarattığımızda aslında o değişkene belirttiğimiz türe göre değişecek varsayılan bir değer atanıyor. Bu varsayılan değer sayı türleri için 0, Boolean için false, bunlar dışındaki referans türleri için de null. O yüzden 6. satırda ciftMi değişkeninin değeri olarak ekrana false yazılacak. ciftMi değişkeninin değerinin sonradan değiştirilebildiğini görüyorsunuz.

var ile ilgili bir not; eğer Scala’yı önerildiği gibi, fonksiyonel programlamaya uygun kullanmak istiyorsanız hiç var kullanmamaya çalışın. İleride değişmezlik (immutability) hakkında yazacağım yazı(lar)da bu konuya tekrar değineceğim. 🙂

1.2. Değer (val)

Değerini sonradan değiştiremeyeceğimiz bir değer veya nesne oluşturmak için val özel kelimesini (İngilizce değer anlamına gelen value‘nun kısa hali) kullanabiliriz. val ile değerler yaratmak Java’da ve başka bazı dillerde değişken tanımının önüne final özel kelimesini getirmeye eşdeğerdir. Bir kere oluşturulur, değeri sabittir, yeniden atama yapılamaz. var için olana benzer bir örnek yapalım.

	val sayi: Int = 6
	val metin = "Sayı çift mi?"
	// Bu hata verecek.
	val ciftMi: Boolean = _
	// Bu da hata verecek.
	sayi = 5

view raw

ScalaTemelKavramlar2.scala

hosted with ❤ by GitHub

Burada da aynı şekilde bir Int ve String oluşturuyoruz yalnız bu sefer bu değerlere yeniden atama yaparak sakladıkları değerleri değiştiremeyeceğiz.

4. satırda gördüğünüz gibi val ile oluşturulmuş bir değerin saklayacağı değeri belirtmeden geçemiyorsunuz çünkü o val bir kere oluşturulduktan sonra değerinin değiştirilmesi engellenecek, sonradan değer ataması yapılamayacak.

7. satırdaki işlem de hata verecek çünkü daha önceden tanımlanmış bir val’ın sakladığı değerin yerine başka bir değer atamaya çalışıyoruz.

var ile ilgili yazdığım notu tamamlayayım; değişmezliği sağlayabilmek için var değil val kullanmaya çalışın. 🙂

2. Metodlar (def)

Aslında daha önceki yazılarımdaki örneklerde metodları kullanmıştık. Scala’da metodlar def özel kelimesi ile tanımlanırlar. Hemen birkaç örnek görelim.

	def buBirMetod {}
	def buDa = {}
	def hattaBuDa: Unit = {}
	def veHattaBuDa(): Unit = {}
	buBirMetod
	veHattaBuDa()
	def sayi = 5
	def sayi2() = 6
	def topla(s1: Int, s2: Int) = s1 + s2
	def carp(s1: Int)(s2: Int) = s1 * s2
	def karistir() = {
	val sonuc1 = topla(sayi, sayi2())
	val sonuc2 = carp(sayi)(sayi2())
	topla(sonuc1, sonuc2)
	}
	val toplam = topla(2, 3)
	val carpim = carp(3)(5)
	karistir()

view raw

ScalaTemelKavramlar3.scala

hosted with ❤ by GitHub

Yukarıdaki örnekte birçok değişik metod tanımlaması görüyorsunuz. İlk 4 metod tanımlaması da aslında bir işlem yapmayan, Unit dönüş türüne sahip, gövdesi boş metodlar. Ama tanımlanışlarında farklılıklar var.

İlk metod hiç parametre tanımlamıyor. Şimdiye kadar gördüklerimiz aksine dönüş türü de belirtmiyor. Gövdesinin boş olduğunu görüyorsunuz, yani bir iş yapmıyor, yani aslında dönüş türünün Unit olması gerekirdi. Scala’da Unit dönüş türüne sahip metodları tanımlarken = (eşittir) işaretini ve dönüş türünü birlikte atlayabiliyoruz.

İkinci metod da aslında ilk metod ile birebir aynı. Parametre almıyor ve dönüş türü Unit. Yalnız bu sefer = kullandığımız için Scala tür çıkarımı yapıyor. Gövde boş olduğu için de (aslında Unit döndüren bir şeylerle dolu da olabilirdi) metodun dönüş türünün Unit olduğuna karar veriyor.

Üçüncü metod da ikinci metod ile aynı. Bu sefer dönüş türünü kendimiz belirttik.

Dördüncü metodda diğer üç metoddan farklı bir nokta var. Bu metod aslında diğerleri gibi parametresiz bir metod değil. Parametre alacak şekilde ama parametresi olmadan tanımlanmış. Scala’da parametresiz tanımlanmış bir metodu parantezlerle, parametre alacak bir metodu da parantezleri olmadan çağırmaya kalkarsak hata alıyoruz. 6. ve 7. satırlarda bu metodları çağırma sırasındaki farkı görüyorsunuz.

9. satırdan itibaren tanımladığımız metodlar (tür çıkarımı ile) geriye Int döndüren metodlar.

sayi ve sayi2() metodları arasında buBirMetod ve veHattaBuDa() metodlarının arasındaki ilişkinin aynısı var. Sonraki satırlarda farklı şekillerde çağırıldıklarını görüyorsunuz.

topla metodu 2 tane Int parametresi olan bir metod. Belki de buradaki en anlaşılır metod. 🙂

carp metodunda ilginç bir farklılık var. Bu metodun 2 tane parametre grubu var. Scala’da metodların birden fazla parametre grupları olabiliyor. Ayrı parantezler halinde yazılıyorlar ve metodun imzasına dahil ediliyorlar. Buradaki metod carp(Int)(Int): Int şeklinde bir imzaya sahip. Metodun nasıl çağrıldığını 21. satırda görüyorsunuz.

karistir() metodu şimdiye kadar tanımladıklarımızı kullanıp bazı hesaplamalar yapan bir metod. Bu metod da veHattaBuDa() metodu gibi parametre alacak şekilde ama parametresi olmadan tanımlanmış. Gövdesinde birden fazla ifade olacağı için süslü parantezler {} kullanılıyor. Son olarak, gövdesindeki son ifadenin değerini geri döndürüyor (tür çıkarımı da buna göre yapılıyor).

Scala’da metodlar, Java’daki gibi sadece bir class içinde değil, başka yerlerde de tanımlanabiliyor, örneğin başka bir metodun içinde. 🙂 Bunun bir örneğini görelim.

	def beni {
	def ben {println("Bir ben vardır bende benden içeri.")}
	println("Beni bende deme bende değilim,")
	ben
	}
	beni
	// Bu hata verecek
	ben

view raw

ScalaTemelKavramlar4.scala

hosted with ❤ by GitHub

Burada ben metodunun beni metodunun içinde tanımlandığını görüyorsunuz. Scala’da bu mümkün. Bir metodun içinde tanımlanan başka bir metod, sadece tanımlandığı metodun gövdesi içinde ulaşılabilir durumdadır. Yukarıdaki örnekte 10. satırda ben metodu bulunamadığı için hata alınacak.

Metodlarla ilgili değinmek istediğim son bir konu var. Scala’da parametreleri olan metodları çağırırken, bu parametreleri isimlerini de kullanarak gönderebilirsiniz. Yapmanız gereken parametrenin değerinin önüne adını yazmak ve = (eşittir) atama işaretini koymak. Bu özelliği kullanarak parametre listesini birebir takip etmeden bile metodunuzu çağırabilirsiniz. Bunun da örneklerini görelim.

	def tanit(adi: String, soyadi: String, yasi: Int, erkekMi: Boolean): Unit = {
	def cinsiyet(e: Boolean): String = {
	if (e) {
	"Erkek"
	} else {
	"Kadın"
	}
	}
	println("Adı : " + adi)
	println("Soyadı : " + soyadi)
	println("Yaşı : " + yasi)
	println("Cinsiyeti: " + cinsiyet(erkekMi))
	}
	tanit("Mehmet Akif", "Tütüncü", 24, true)
	tanit(adi = "Mehmet Akif", soyadi = "Tütüncü", yasi = 24, erkekMi = true)
	tanit("Mehmet Akif", soyadi = "Tütüncü", 24, erkekMi = true)
	tanit(soyadi = "Tütüncü", erkekMi = true, adi = "Mehmet Akif", yasi = 24)

view raw

ScalaTemelKavramlar5.scala

hosted with ❤ by GitHub

Bu örnekte tanit adında, 4 tane parametresi olan, Unit döndüren bir metod tanımlıyoruz. Burada cinsiyet metoduyla, yukarıda bahsettiğim metod içinde başka bir metod tanımlamanın bir örneğini daha görüyorsunuz. Gönderilen erkekMi parametresinin değerine göre kişinin cinsiyetine karar verecek küçük yardımcı bir metod. Bu metodun gövdesinde karar vermeye yarayan if özel kelimesi var. Bundan sonraki yazılarımda daha detaylı bahsedeceğim. Şimdi 16. satırdan itibaren metodun farklı şekillerde çağrılışlarını inceleyelim.

16. satırda şimdiye kadar bildiğimiz yöntemle, sırayla parametreleri vererek çağırıyoruz.

17. satırda birer birer bütün parametrelerin isimlerini de vererek çağırıyoruz. Gördüğünüz gibi bu yöntem kodun okunduğunda daha kolay anlaşılmasına yardımcı oluyor. Tabi bunun için metodu tanımlarken parametrelere anlamlı isimler vermek gerekiyor.

18. satırda parametrelerin hepsine değil, sadece bazılarına isimlerini de vererek değer gönderiyoruz. Bu yine bazı durumlarda kodun anlaşılabilirliğini artırmak için güzel bir yöntem. Özellikle türü Boolean olan parametrelerin değerlerini verirken isimleriyle çağırmanızı tavsiye ederim. Burada hala parametreleri gerçek sıralarıyla çağırdığımıza dikkat edin.

19. satırda işler biraz daha değişiyor. Artık parametreleri kendi istediğimiz sırada gönderiyoruz. Tüm parametreleri tanımladığımız için ve hepsini ismiyle gönderdiğimiz için Scala metod çağrılarını bu şekilde yapmamıza bile izin veriyor.

Ekleme: Metod Parametrelerinde Varsayılan Değerler

Yazıyı yazıp yayımladıktan sonra atladığımı fark ettiğim için eklemek istediğim, metodlar yazarken sıkça kullanılan bir konu daha var. Scala’da metodların parametrelerine varsayılan değerler belirleyebilirsiniz. Böylece metodu çağırırken varsayılan değeri olan bir parametreyi yazmadan da geçebilirsiniz. Böyle durumlarda metod tanımlanırken belirtilen varsayılan değer kullanılır. Bir örnek ile görelim.

	def tanit(adi: String, soyadi: String, yasi: Int, erkekMi: Boolean, sadeceAdiKullan: Boolean = false): Unit = {
	def cinsiyet(e: Boolean): String = {
	if (e) {
	"Erkek"
	} else {
	"Kadın"
	}
	}
	println("Adı : " + adi)
	if (!sadeceAdiKullan) {
	println("Soyadı : " + soyadi)
	println("Yaşı : " + yasi)
	println("Cinsiyeti: " + cinsiyet(erkekMi))
	}
	}
	// Bunlar önceki örnekteki gibi çalışacak.
	tanit("Mehmet Akif", "Tütüncü", 24, true)
	tanit("Mehmet Akif", "Tütüncü", 24, erkekMi = true)
	// Bunlar sadece adı yazdıracak.
	tanit("Mehmet Akif", "Tütüncü", 24, true, true)
	tanit("Mehmet Akif", "Tütüncü", 24, true, sadeceAdiKullan = true)
	tanit("Mehmet Akif", "Tütüncü", 24, erkekMi = true, sadeceAdiKullan = true)

view raw

ScalaTemelKavramlar6.scala

hosted with ❤ by GitHub

Bir önceki örnekteki metoda sadeceAdiKullan adında bir Boolean parametre daha ekledim. Bu parametrenin varsayılan bir değeri var, false. Ve metodun işleyişi bu parametrenin değerine göre değişiyor. 20 ve 21. satırlarda gördüğünüz gibi sadeceAdiKullan parametresini hiç dahil etmeden de metodu çağırabiliyoruz. Bu durumda bu parametrenin değeri varsayılan değer olan belirtilen değer oluyor. Ama 24, 25 ve 26. satırlardaki kullanımda sadeceAdiKullan parametresini de işin içine katıyoruz ve istediğimiz değeri belirtiyoruz.

Bu eklemeyle beraber metod parametrelerini isimleriyle kullanma konusunda bir tavsiyede bulunayım. Metodun parametrelerini gönderirken okunurluğu artırmak adına parametreleri, özellike de türü Boolean olan parametreleri, isimlerini kullanarak gönderin. Yukarıdaki örnekte 21. ve 26. satırdaki kullanımlar buna örnekler. 🙂

Sonuç

Bu yazımda programlamadaki temel kavramlardan değişken, sabit değer ve metodları ve bunların Scala’daki kullanılışlarını anlatmaya çalıştım. İnşallah anlaşılır olmuştur.

Kaynak

Yunus Emre’nin Severim Ben Seni Candan İçeri şiiri: http://www.yunusemre.gov.tr/index.php/eserleri/siirleri/siirlerin-devami/severim-ben-seni-candan-iceri

Görüşmek üzere. Hoşça kalın!

 

Scala’da Türler ve Tür Çıkarımı (Type Inference)

Herkese merhaba! Bu yazımda Scala’nın veri türlerinden ve türlerle ilgili güzel bir özelliğinden bahsedeceğim.

Haydi başlayalım.

Scala’daki Veri Türleri ve İlişkileri

Diğer birçok programlama dilini öğrenirken olduğu gibi Scala’yı öğrenirken de dilde bulunan temel veri türlerini, bunların birbirleriyle, daha karmaşık türlerle ve sizin sonradan tanımlayabileceğiniz türlerle ilişkilerini mümkün olduğunda erken öğrenmek gerekiyor. Aşağıda Scala’daki türlerle ilgili genel bir şema görüyorsunuz.

Şimdi detaylara inelim.

1. Temel Türler

Başka dillerde, özellikle Java’da, geliştirme yaptıysanız aşina olduğunuz basit veri türleridir.

Bellekte kapladığı alana göre küçükten büyüğe Byte, Short, Int, Long, Float, Double türleri sayısal değerler için; Char türü tek bir karakter saklamak için; Boolean değeri true veya false olabilen mantıksal değerler için; Unit de Java’daki void türüne karşılık gelen hiçlik için tanımlanmış türlerdir. Bu türlerin hepsi AnyVal türünden türer. Ayrıca bu türlerin hepsi derlenmiş bytecode seviyesinde doğrudan Java’daki karşılıkları olan türlerdir. Yani Scala bu türleri kullandığınızda arka tarafta doğrudan Java türlerini kullanır.

Scala bu temel türler arasında gizli dönüşümler yapabilir. Böylece dönüşüme uygun bir türü başka bir türü gerektiren yerde kullanabilirsiniz. Bu dönüşümler yukarıdaki şemada da görebileceğiniz gibi; sayı türleri için küçük olanından büyük olana dönüşümler ve Char türünden Int türüne dönüşümdür. Örneğin Double gerektiren bir yerde Float türünden bir değeri kullanabilirsiniz, dönüşüm kendiliğinden yapılacaktır.

2. Any ve Nothing

Any türü tüm türlerin üstündedir. Tüm Scala değerleri, nesneleri ve türleri Any’den türerler. (Java’daki Object’ten farklıdır, birazdan bahsedeceğim.)

Nothing türü de tüm türlerin altındadır. Nothing, tüm Scala değerlerinden, nesnelerinden ve türlerinden türer. Bu tür, özellikle birçok tür için genel (Array gibi herhangi bir türde olabilen, türü de parametre olarak alan yapılarda) kodlar yazarken, türler arasındaki ilişkileri tanımlamada işe yarayabiliyor.

3. String, Null ve ScalaObject

Scala’daki String türü özel bir tür değildir. Aynen temel türler gibi aslında doğrudan Java’daki String türünü kullanır.

Null türü Nothing türü gibidir ama her türün değil, temel türler hariç tüm türlerin altındadır. Bellekteki geçersiz bir referansı temsil eder. Null kavramı başta Java olmak üzere diğer birçok dilde sevilmeyen bir kavramdır ve Scala’da da uzak durulmasını tavsiye ederim. 🙂

ScalaObject türü Scala’da tanımlanmış, temel türler dışındaki tüm türlerin üstündedir. Bahsi geçen tüm türler ScalaObject’ten türerler. Java’daki Object’e benzer ama birebir karşılığı değildir.

4. AnyVal ve AnyRef

AnyVal türü Scala’daki temel türlerin üst türüdür. Bu tür sayesinde sadece temel türden olan değerleri karşılayacak kodlar yazmak daha kolay hale geliyor.

AnyRef türü de Java’da tüm türlerin üstünde olan Object‘e karşılık gelen türdür. ScalaObject olan her tür (temel türlerden olmayan, referans türü olan tüm Scala nesneleri) ve Scala kodu içinde erişilen Java nesneleri AnyRef’ten türerler.

Tür Çıkarımı/Tahmini (Type Inference)

Scala statik türlü bir dildir. Yani tanımladığınız her değerin daha derleme anında bir türü olması gerekir. Java ve onun gibi statik türlü başka birçok dilde bir değer, değişken, parametre vb. tanımlarken türünü de belirtmeniz gerekir. Bu durumlarda Scala’da da tür belirtebilirsiniz. Ama dilerseniz türü yazmayabilirsiniz ve Scala sizin yerinize tür hakkında çıkarım yapabilir. Türü belirtmediğinizde dinamik türlü gibi görünen, daha kısa ve öz bir koda sahip olursunuz ama hala yazdığınız kod statik türlüdür ve türle ilgili bir sorun varsa bunu derleme anında yakalarsınız. Daha önce Scala’da aslında kesinlikle gerekli olmayan şeylerin atılabildiğinden bahsetmiştim. Tür çıkarımı da buna güzel bir örnek. 🙂 Küçük bir kod parçasıyla tür çıkarımının nasıl göründüğüne bakalım.

	val a: Char = 'a'
	val b: Int = 3
	val c: Long = 5
	val d: Boolean = true
	// Scala Double'ı Float'a tercih eder. Özellikle Float istediğimiz için tür dönüşümü yapıyoruz.
	val e: Float = (3.14).asInstanceOf[Float]
	val f: String = "e"
	val any1: Array[Any] = Array(a, b, c, d, e, f)
	val k = 'k' // k bir Char olacak.
	val l = 5 // l bir Int olacak.
	val m = 8L // m bir Long olacak.
	val n = false // n bir Boolean olacak.
	val o = 3.14 // o bir Double olacak. (e'deki not yüzünden)
	val p = "o" // p bir String olacak.
	// any2 bir Array[Any] olacak.
	val any2 = Array(k, l, m, n, o, p)

view raw

ScalaTurCikarimi.scala

hosted with ❤ by GitHub

Yukarıdaki örnekte tür çıkarımından yararlanarak tanımladığımız değerlerin türlerini belirtmeyebileceğimizi görüyorsunuz. Ayrıca tür dönüşümü yapmanın da bir örneği var. Hatta türler arasındaki ilişki yüzünden any1 ve any2 değerlerinin, verilen türlerin hepsinin üst türü olan Any türünden bir Array olduğunu da görüyorsunuz. Yukarıdaki şemada bulunan ama açıklamadığım List, Seq, Iterable gibi türler ve burada bahsettiğim Array türleri ile – hatta Scala’nın koleksiyon kütüphanesi ile – ilgili daha sonra detaylı bir yazı yazacağım. Scala’nın koleksiyon kütüphanesi öyle kısaca anlatılacak gibi değil çünkü. 🙂

Peki tür çıkarımı herhangi bir yerde türleri yazmaktan vazgeçebileceğiniz anlamına mı geliyor? Hayır. Aşağıdaki örneğe bakalım.

	def dogru(a: String, b: Int, c: Boolean): Long = {
	// Burada Long türünde bir değer olacak.
	}
	// Metodun dönüş değerinin türü de çıkarımla bulunabilir çünkü gövdedeki son ifadenin değeri geri döndürülecek.
	// Haliyle metodun dönüş değerinin türü de bu son ifadenin değerinin türü olacak.
	// Dolayısıyla metod imzasından dönüş türünü atabiliriz.
	def buDaDogru(a: String, b: Int, c: Boolean) = dogru(a, b, c)
	// Bu hata verecek çünkü Scala statik türlü.
	// Metod a, b, ve c ile bir şeyler yapacak. Türlerinin bilinmesi gerek.
	def buYanlis(a, b, c) = {
	// Neredeyim ben? Neler oluyor?
	}

view raw

ScalaTurCikarimi2.scala

hosted with ❤ by GitHub

Burada metodların dönüş türünü tür çıkarımı için yazmayabileceğinizi ve tür çıkarımını kullanmanın yaratabileceği bir sorunu görüyorsunuz. Henüz bahsetmedim ama, kendi class’larınızı ve türlerinizi tanımlarken ve buradaki gibi metod parametreleri tanımlarken – türün kesin olarak bilinmesi gereken yerlerde – tür çıkarımı kullanmaya çalışmak hata almanıza neden olacaktır.

Tür çıkarımı ilginç, güzel, kullanışlı ama aynı zamanda biraz da tehlikeli bir özellik. Muhtemelen ilk başlarda her yerde kullanmak isteyeceksiniz ama 2 yıldır Scala ile geliştirme yapan birisi olarak tür çıkarımını kullanmak konusunda şu tavsiyeleri verebilirim:

1. Tür çıkarımı kullanacaksanız isimlendirmelerinizde mutlaka okuduğunuzda size tür hakkında da fikir verecek bir isim seçin. Sonra kodunuz büyüdükçe

   val temp = Foo.bar

   gibi bir koda bakıp

   Bu ‘temp’ değeri ne şimdi? Türü ne bunun?

   diye saç baş yolabiliyorsunuz çünkü. 🙂

2. Metodlarınızın dönüş türlerini yazmayıp tür çıkarımı yapmak istiyorsanız bir kere daha düşünün. Yukarıda bahsettiğim gibi kodunuz büyüdükçe metodun ne döndürdüğünü bir bakışta anlayamamak sizin için sorun olmaya başlayacaktır. Eğer metod küçükse ve ne döndürdüğünü bir bakışta görebiliyorsanız tür çıkarımı kullanmakta bir sakınca yok.

Sonuç

Bu yazımda Scala’daki türlerden, birbirleriyle ve Java’daki türlerle olan ilişkilerinden ve tür çıkarımından bahsetmeye çalıştım. İnşallah anlaşılır olmuştur.

Bir sonraki yazıda görüşmek üzere. Hoşça kalın!

Kaynaklar

Türlerle ilgili şema için: http://docs.scala-lang.org/tutorials/tour/unified-types.html

Neden Scala?

Merhabalar! Bu yazımda Scala’nın onu tercih sebebiniz olabilecek birkaç avantajından bahsetmek istiyorum. Merhaba Scala! yazımda ve Kim? sayfamda biraz bahsettiğim gibi Linovi’de çalışıyorum ve Scala’yı öğrenmeye/kullanmaya burada başladım. Scala ile ilgili şirketimin tercihleri ve benim kişisel görüşlerimi göz önünde bulundurarak birkaç başlık halinde anlatacağım.

Java ile Yakın İlişki

Java en yaygın programlama dillerinden bir tanesi. Java ile yapılabilecekler gerçekten oldukça fazla. Çok çeşitli ortamlarda da çalışabiliyor. Haliyle Java ile yazılmış dünya kadar kütüphane, araç ve çözüm var. Ancak eğer siz bir şekilde Java ile geliştirme yapmıyorsanız, geliştirdiğiniz dilden başka bir dilde yazılmış bir kodu kullanmak ya ek çaba gerektirecektir ya da mümkün değildir. Scala ile geliştirme yapacak olursanız böyle bir sorunla karşılaşmazsınız. Scala da tıpkı Java gibi JVM üzerinde çalışır. Scala kodunuzla birlikte Java kodu yazabilir, Scala kodunuzda Java kütüphanelerini doğrudan kullanabilir ve Java’yı çalıştırabildiğiniz bir ortamda Scala’yı da çalıştırabilirsiniz. Gördüğünüz gibi, bir nedenden dolayı Java’yı değil başka bir dili tercih etmek durumundaysanız, Scala’nın Java ile bu yakın ilişkisi sizin için avantajlı olabilir. Şirketimin Scala tercihinde de Java ile olan bu ilişki önemli bir etken. Örneğin yoğun olarak kullandığımız Amazon’un AWS (Amazon Web Services) isimli bulut (cloud) hizmetleri için hazırlanmış arayüzler ve kütüphaneler Java ile yazılmış durumda ve biz Scala kodumuzla birlikte sorunsuzca kullanabiliyoruz.

Yüksek Performanslı, Eşzamanlı İşler

Scala ile Akka teknolojilerini kullanarak eşzamanlı (concurrent), dağıtık (distributed) ve yüksek performanslı sistemler geliştirebilirsiniz. Evet, Akka teknolojilerini Java’da ve başka dillerde de kullanabiliyorsunuz ama bu teknolojileri Scala ile de sorunsuzca kullanabilmek yine bir avantaj. Hatta Scala’nın (fonksiyonel programlama gibi) farklı yetenekleriyle de birleşince bu teknolojileri Scala ile kullanmak daha kolay ve etkili olabiliyor. Linovi’de Akka’nın aktörlerini Scala ile kullanıyoruz.

Fonksiyonel Programlama

Scala birden fazla programlama paradigmasını/modelini destekleyecek şekilde geliştirilmiş. Nesne yönelimli programlama modelini tıpkı Java’daki veya başka bir nesne yönelimli programlama destekleyen dildeki gibi kullanabiliyorsunuz. Hatta bunun üzerine iyileştirmeler de yapılmış. Bunlara ek olarak Scala ile nesne yönelimli programlamadan oldukça farklı olan fonksiyonel programlama modelini de kullanabiliyorsunuz. Scala bu iki temel programlama modellerini başarılı şekilde harmanlamış. Dilin size sunduğu birçok kütüphanede ve arayüzde fonksiyonel programlama özellikleri ve tekniklerinden yararlanılmış. Hatta – daha önce bahsetmiştim – Scala birçok yerde sizi fonksiyonel programlama yapmaya teşvik ediyor. İlerleyen yazılarımda Scala ile daha çok kodlama yaptıkça bunun detaylarına ineceğim.

Kısa ve Öz Sözdizimi

Bu yazıyı okuyorsanız muhtemelen Scala dışında bir dil kullanıyorsunuzdur. Hatta o dilin Java olma ihtimali de oldukça yüksek. 🙂 Java ile geliştirme yapmışsanız bilirsiniz ki bazen basit bir iş için bile çok fazla kod yazarız. Benzer şeyleri tekrar tekrar yazarız ve yaptığımız işler büyüdükçe bu durum biraz can sıkmaya başlar. Scala geliştirilirken, bu gibi can sıkıcı durumlardan kurtulmak için birçok noktada neyin gerçekten gerekli olduğu, neyin ise aslında gereksiz olduğu ve atılabileceği üzerinde düşünülmüş. Örnek olması için; bir İnsan sınıfı tanımlayan, 10 tane rastgele yaşlara sahip insan oluşturan, bunları listeleyen ve sonra yaşlarının toplamını gösteren bir kod yazdım. Aşağıda aynı kodun birbirine denk Java ve Scala ile yazılmış hallerini görebilirsiniz.

Java

	class Insan {
	private int yas;
	public Insan(int yas) {
	this.yas = yas;
	}
	public int yas() {
	return yas;
	}
	@Override public String toString() {
	return "Insan(" + yas + ")";
	}
	}
	class NedenScala {
	public static void main(String[] args) {
	Random rastgele = new Random();
	Insan[] insanlar = new Insan[10];
	for (int i = 0; i < 10; i++) {
	insanlar[i] = new Insan(rastgele.nextInt(30) + 5);
	}
	System.out.println("İnsanlar:");
	for (Insan insan : insanlar) {
	System.out.println(insan);
	}
	System.out.println("Yaşları toplamı:");
	int toplam = 0;
	for (Insan insan : insanlar) {
	toplam += insan.yas();
	}
	System.out.println(toplam);
	}
	}

view raw

NedenScala.java

hosted with ❤ by GitHub

Scala

	case class Insan(yas: Int)
	object NedenScala {
	def main(args: Array[String]) {
	val insanlar = for (i <- 1 to 10) yield Insan(scala.util.Random.nextInt(30) + 5)
	println("İnsanlar:")
	insanlar foreach println
	println("Yaşları toplamı:")
	println(insanlar.foldLeft(0)(_ + _.yas))
	}
	}

view raw

NedenScala.scala

hosted with ❤ by GitHub

Aradaki farkı görüyorsunuz. 🙂 Kodun Scala halinde ileride detaylıca bahsedeceğim (tür çıkarımı/tahmini [type inference], sadece döngü olmayan for’lar [for comprehension], koleksiyonlar [collections], fonksiyonel programlama [functional programming], parçalı fonksiyonlar [partial functions] gibi) birçok Scala özelliğini kullandım. Her ne kadar örnek olsun diye uydurduğum bir kod olsa da Java’da, da Scala’da da geliştirme yapmış biri olarak farkın gerçekten de bu boyutlara ulaştığını söyleyebilirim. Scala’yı tercih etmemdeki kişisel nedenlerden birisi de bu Scala’nın bu öz (concise) yapısı.

Play Framework ve Web Uygulamaları

Yukarıda Akka’dan bahsederken anlattığım gibi, Scala ile web uygulamaları geliştirmek için Play Framework‘ü kullanabilirsiniz. Yine Akka gibi Play Framework de Java ile çalışabilmesine rağmen Scala ile daha kolay, keyifli ve etkili geliştirmeye olanak sağlıyor. Ayrıca Play Framework geliştiricileri önce Scala, sonra Java için geliştirme yapıyorlar diye biliyorum. Yani Play Framework kullanacaksanız Scala’nın Java’ya göre desteklenme konusunda bir avantajı var. Ayrıca Scala’daki implicit kavramı ve fonksiyonel programlama özellikleri gibi gelişmiş yapılar, web uygulamalarınızı geliştirirken size gerçekten çok yardımcı olabiliyor ve uygulamalarınızı daha etkin biçimde geliştirebiliyorsunuz. Linovi’de yüksek performanslı ve kaliteli web uygulamaları geliştirmeyi hedeflediğimiz için Play Framework’ü tercih ediyoruz. Çünkü Play Framework hafif ve iyi bir performansla çalışıyor. İlerleyen zamanlarda Scala ile Play Framework üzerine yazılar yazacağım.

Sonuç

Bu yazımda Scala ile ilgili “Neden Scala öğreneyim/kullanayım?”, “Neden Scala’ya geçeyim?” gibi sorularınıza cevaplar vermeye çalıştım. İnşallah anlattıklarım faydalı olmuştur.

Tekrar görüşmek üzere, hoşça kalın!

Merhaba Scala!

Herkese merhaba!  Scala ile ilgili bu ilk yazımda Scala’nın ne olduğundan, geliştirme yapmak için nelerin gerektiğinden bahsedeceğim ve hızlı bir giriş yapmak adına artık gelenek haline gelmiş “Hello world!” uygulamasını göstereceğim. İlerleyen zamanlarda da fırsat buldukça yeni yazılarla başka birçok konuyu anlatmaya çalışacağım. Ben Scala’yı 2 yıldır öğreniyor/kullanıyorum ve çok seviyorum. İnşallah anlattıklarımdan sonra siz de seversiniz. 🙂

Not: Yazılarımda sık sık diğer programlama dilleri ve özellikle Java ile Scala arasında karşılaştırmalar yapacağım.

Haydi başlayalım!

Scala Nedir?

http://www.scala-lang.org/

Scala bir programlama dilidir. 2003 yılında İsviçre’de Martin Odersky ve EPFL’deki araştırma grubu tarafından geliştirilmiş ve bugüne kadar oldukça büyümüş. Günümüzde dünya çapında yüzbinlerce kullanıcısı var ve yine dünya çapında çok sayıda insan tarafından geliştirilmekte ve sürdürülmekte. Açık kaynaklı bir dil. Derlendiği zaman Java kodu üretiliyor ve Java Sanal Makinası (JVM) üzerinde çalışıyor. Yani Java’nın çalıştırığı her yerde Scala da çalıştırabiliyorsunuz. Hatta Scala ile Java kodunu birlikte bile kullanabiliyorsunuz. Scala ile nesne yönelimli programlama (object-oriented programming, OOP) ve ek olarak fonksiyonel programlama yapabiliyorsunuz. Hatta Scala birçok noktada fonksiyonel programlama yöntemlerini kullanmaya teşvik ediyor. Sözdizimi (syntax) olarak kendine özgü yanları var ve düşündüğünüzde gerçekten fazlalık olan birçok şey atılmış. Bu konulara ilerleyen yazılarda daha detaylı değineceğim ve Scala’nın Play Framework ile birlikte web uygulamarı geliştirmek için kullanımını anlatacağım.

Ne Gerekir ve Nasıl Kurulur?

Scala ile geliştirme yapmaya başlamak için 3 temel şeye ihtiyacınız var.

1. Kod yazabileceğiniz bir metin düzenleyici veya geliştirme ortamı
2. Kodunuzu derleyebilmek için Scala
3. Derlediğiniz uygulamanızı çalıştırabilmek için Java

Yüklemelerin detaylarına inmeyeceğim. Eğer bir sorunuz olursa yorum yazabilirsiniz, daha detaylı konuşabiliriz.

Ben yazılarım sırasındaki geliştirmeyi Mac OS X üzerinde Java 8 ve Scala 2.11.7 sürümleri ile yapacağım. Kod yazmak için de yerine göre Sublime Text 3 metin düzenleyici ve IntelliJ IDEA 15 kullanacağım. Yazılarıma ekleyeceğim kod parçalarını da Github’ın Gist özelliğini kullanarak ekleyeceğim.

Yüklemelerinizde yardımcı olması açısından yukarıda bahsettiklerimin bağlantılarını da vereyim.

• Scala: http://www.scala-lang.org/download
• Java: http://www.oracle.com/technetwork/java/javase/downloads/index.html
• Sublime Text: http://www.sublimetext.com
• IntelliJ IDEA: https://www.jetbrains.com/idea

İlk Scala Programı

Haydi artık ilk uygulamamızı görelim ve üzerine biraz konuşalım.

	object MerhabaScala {
	def main(args: Array[String]): Unit = {
	println("Merhaba Scala!")
	}
	}

view raw

MerhabaScala.scala

hosted with ❤ by GitHub

Yukarıda gördüğünüz yazabileceğimiz belki de en basit uygulama. Tek yaptığı şey varsayılan çıktı kanalına (yani uygulamayı çalıştıracağınız terminal ekranına) bir satır halinde “Merhaba Scala!” yazmak. Şimdi biraz daha detaylara girelim. Daha çok başlarda olduğumuzdan adım adım ilerleyeceğim ama ilerideki yazılarda bu kadar detaya in(e)meyebilirim. 🙂

İlk satırda object özel kelimesiyle “MerhabaScala” isimli bir Scala objesi oluşturuyoruz. Objelerin detaylarını ilerleyen yazılarda anlatacağım. Şimdilik bunu Java’daki bir class gibi düşünebilirsiniz.

İkinci satırda Scala’nın sözdizimi ile ilgili – eğer başka dillerle, özellikle Java ile geliştirme yapıyorsanız dikkatinizi çekecek – ilk farklılıklarla karşı karşıyayız. def özel kelimesiyle bir metod tanımlıyoruz. Metodumuzun adı “main” ve diğer birçok dildeki gibi uygulamamızın başlayacağı noktayı belirliyor. Şu an için yazmadık ama başka sınıflarımız, objelerimiz ve metodlarımız olsaydı bile uygulamamız bu main metodu ile çalışmaya başlayacaktı. Metodun adından sonra parantezler içinde metodun parametrelerini tanımlıyoruz. Metodumuzun 1 tane parametresi var. Bu parametre uygulamamız çalıştırılırken ona aktarılan komut satırı parametrelerine karşılık gelecek bir String dizisi. İlerleyen yazılarımda bu konuya da değinmeyi düşünüyorum. Parametrenin adı args ve türü Array[String]. Scala’da bir değişkenin, parametrenin, metodun veya değerin türünü belirtmek için önce adını, sonra türünü yazıyoruz ve bunları : (iki nokta üst üste) ile birbirinden ayırıyoruz. Parametrenin bir dizi (Array) türünde olduğundan bahsetmiştim. Array türüne, Scala’nın sağladığı zengin koleksiyon kütüphanesinden bahsedeceğim yazımda daha detaylı değineceğim. Parametrelerden sonra – tıpkı bir parametrenin türünü belirttiğimiz gibi – metodumuzun geriye döndüreceği türü yazıyoruz. main metodumuz geriye Unit türünde bir değer döndürüyor. Unit türü Java ve başka bazı dillerdeki hiçlik belirten void türüne karşılık geliyor. Yani aslında main metodumuz geriye bir değer döndürmeyecek, sadece bazı işlemler yapacak. Metodun dönüş türünü de belirttikten sonra metodun imzasının bittiğini ve gövdesinin başlayacağını belirtmek için = (eşittir) işareti yazıyoruz. Daha sonra metodun gövdesini yazıyoruz. Metodun gövdesini süslü parantezler {} arasına yazıyoruz. Eğer metodun sadece bir satırlık bir gövdesi olacaksa, Scala süslü parantezleri kullanmadan da yazmamıza izin veriyor. Yukarıda bahsettiğim gibi, Scala’da birçok durumda eğer bir şey kesinlikle gerekmiyorsa onu atabiliyoruz. Bunu zamanla göreceğiz. 🙂

Üçüncü satırda main metodumuzun gövesi başlıyor. Burada uygulamamızın yaptığı tek işi tanımlıyoruz. Yaptığımız şey println (print line) metodunu çağırmak. Metoda doğrudan ulaşabildik çünkü Scala’da her uygulamaya kendiliğinden dahil edilen tanımlamalar var ve println onlardan biri. Bu metod kendisine pasladığımız parametrelerin değerlerini standart çıktı kanalına yazdırıyor ve bir sonraki satıra geçiyor. Java’daki System.out.println metoduna karşılık geliyor. Ayrıca görmüş olduğunuz gibi satır sonunda ; (noktalı virgül) yok. Scala’da – yine gereksiz olduğu için – noktalı virgüller atılmış. İfadeler yeni satırlar ile birbirinden ayrılıyor. Eğer bir satırda birden fazla ifade yazmak istiyorsanız aralarına ; koymanız gerekiyor. Onun dışında neredeyse hiç ihtiyacınız olmayacak.

Şimdi Scala sözdizimine biraz daha aşina olmanız için yukarıda anlattıklarım hakkında bir iki küçük örnek göstereyim ve sonra uygulamalarımızı nasıl çalıştıracağımıza bakalım.

İşte örnek metod tanımlamaları

	def topla(sayi1: Int, sayi2: Int): Int = sayi1 + sayi2
	def toplamCiftMi(sayi1: Int, sayi2: Int): Boolean = {
	val toplam: Int = topla(sayi1, sayi2)
	val mod2: Int = toplam % 2
	mod2 == 0
	}

view raw

MerhabaScala2.scala

hosted with ❤ by GitHub

Gördüğünüz gibi ilk metodumuzun gövdesi tek satırdan oluştuğu için süslü parantezler kullanmadık. Ayrıca metoddan dönecek değeri belirtmek için  return özel kelimesini kullanmadık. Scala metodun gövdesindeki son ifadenin değerini kendiliğinden geri döndürüyor. “val” özel kelimesi ile değeri değişmeyen bir değer tanımlıyoruz. Diğer dillerdeki değişken tanımlama ile aynı yapıda. İlerleyen yazılarımda bunlardan daha detaylı bahsedeceğim.

Scala Uygulamasını Çalıştırmak

Artık uygulamamızı çalıştıralım değil mi? 🙂 Geliştirme yaptığınız ortama göre değişmekle birlikte Scala kodunuzu birkaç farklı şekilde çalıştırabilirsiniz.

1. Scala REPL

Scala, REPL (read-evaluate-print loop) denilen, “oku-değerlendir-yazdır döngüsü” şeklinde Türkçeleştirebileceğim bir yorumlayıcı ile birlikte geliyor. Ben REPL’a “canlı yayında Scala” da diyorum. 🙂 REPL ile doğrudan Scala kodu yazıp çalıştırabilirsiniz. Yazdığınız her ifade anında yorumlanacak ve çalıştırılacaktır. Bir şeyleri denemek, alıştırmalar yapmak gibi birçok iş için harika bir araçtır. Scala kurulumunuzu doğru yaptıysanız bir terminal ekranında (komut satırı) “scala” komutunu çalıştırarak REPL’ı başlatabilirsiniz. Aşağı yukarı şöyle görünüyor.

REPL’dan çıkmak için “:q” komutunu çalıştırabilir veya terminali kapatabilirsiniz.

2. Terminalden “scala” Komutu İle

Scala kodunuzu “.scala” uzantısıyla biten bir dosyaya yazıp bu dosyayı derleyip çalıştırabilirsiniz. İlk uygulamamızı “MerhabaScala.scala” isimli bir dosyaya kaydettikten sonra dosyanın bulunduğu dizinde “scala MerhabaScala.scala” komutu ile uygulamayı çalıştırabilirsiniz. Hazır aklıma gelmişken söyleyeyim. Scala’da, Java’daki gibi dosya adının, içine yazdığınız koddaki sınıf ile hatta genel olarak kod ile bir bağlantısı yok. Bir Scala dosyası içine dosyanın isminden farklı bir veya birkaç sınıf yazabilirsiniz. Hatta sınıf veya objeler olmadan sadece ifadeler yazarak bir script (betik) gibi de çalıştırabilirsiniz. Bu yöntemle çalıştırdığımız ilk uygulamamız aşağıdaki gibi görünecek.

3. Bir Bütünleşik Geliştirme Ortamı (IDE) Kullanarak

Muhtemelen en kolay ve en çok tercih edeceğiniz yöntem bu olacak. Kullanacağınız IDE’ye bağlı olarak değişmekle birlikte genellikle “Uygulamamı derle ve çalıştır.” şeklinde bir komut ile, muhtemelen tek bir tuşa basarak uygulamanızı çalıştırabileceksiniz. Bir IDE olarak IntelliJ IDEA üzerinde Scala geliştirmeyi ayrı bir yazımda anlatacağım ve ondan sonraki yazılarımda IntelliJ IDEA kullanıyor olacağım. Temel konulardan bahsedeceğim ilk yazılarımda 2. yöntemi kullanmak muhtemelen sizin için en kolayı olacak.

Sonuç

Evet, bu yazımda Scala’nın ne olduğundan, Scala ile geliştirme yapmak için nelerin gerektiğinden, Scala ile yazılabilecek ilk uygulamadan ve uygulamaları nasıl çalıştıracağımızdan bahsetmeye çalıştım. Biliyorum, çok fazla “İlerleyen yazılarımda bahsedeceğim.” dedim ama takdir edersiniz ki her şeyi bir yazı ile anlatmam mümkün değil. Mümkün olduğunca küçük parçalar halinde, sizleri sıkmadan yazmaya çalışacağım.

Görüşmek üzere. Hoşça kalın! 🙂

Kaynaklar

Scala hakkında genel bilgiler, tarihçe ve logo için: http://www.scala-lang.org