Ruby, Japon bilgisayar bilimcisi Yukihiro “Matz”
Matsumoto tarafından geliştirilmiş bir programlama
dilidir. Basitlik ve verimlilik dengesi üzerine inşa edilmiş
olan tamamen nesne yönelimli bir dildir. Perl, Pyhon,
SmallTalk, Ada gibi pek çok programlama dilinden
esinlenmiş olan Ruby, aynı zamanda Rust, Swift, Clojure,
Crystal gibi birçok programlama diline de esin kaynağı
olmuştur.
1993 yılında geliştirilmeye başlanmış ve 1995 yılının
sonlarında ilk versiyonu olan Ruby 0.95 yerel bir Japon
haber grubunda duyurularak kullanıma sunulmuştur. 2000
yılına kadar Japonya sınırlarının dışında pek ses
getirememiş olsa da; bu yılda İngilizce olarak ilk kitabın
piyasaya çıkması, haber grupları ve e-posta listeleri
kurulması gibi etkenlerin de yardımıyla dünya çapında ilgi
uyandırmaya başlamıştır. Ruby dilinin asıl manada dünya
çapında kullanılmaya başlanması ise Ruby on Rails isimli
web çerçevesi ile birlikte olmuştur. Bu ünitenin yazımı
sırasında Ruby’nin kullanılabilir durumda olan en son
kararlı hali 2.3.1 sürümüdür.

Ruby dilinin geliştirilmesi aşamasında pek çok
programlama dilinden esinlenilmiştir. Ruby, gerek bu
dillerin bazılarının doğasında var olan, gerekse Matz
tarafından adapte edilmiş olan pek çok felsefi temel
üzerine inşa edilmiştir. Bunları birkaç madde ile şöyle
özetleyebiliriz:
İnsan Faktörü Prensibi: Matz’in diğer dillerle ilgili en çok
yakındığı nokta: bu dilleri kullanan programcıların,
özellikle bilgisayar mühendislerinin, program yazarken
işlevsellik yerine makinenin daha hızlı ve verimli
çalışmasına odaklanmalarıydı. Bunu yaparken insan
faktörü sürekli göz ardı ediliyordu. Halbuki bizler,
bilgisayar programlarının büyük bir bölümünü insanlarla
etkileşim halinde olması için tasarlamaktayız. Bu nedenle
programlama dilleri makineden çok insan faktörü
düşünülerek tasarlanmalıdır. Matz bunu şu ifadeyle açıkça
dile getirmektedir: “Onlar (bilgisayarlar) köle, bizler
efendiyiz.”
Asgari Sürpriz Prensibi: Bilgisayar bilimleri haricinde
başka alanlarda da uygulaması bulunan bu prensip gereği
bir işlemin sonucu tahmin edilebilir, açık ve tutarlı
olmalıdır. Matz bu durumu birkaç cümlede şöyle ifade
etmektedir: “İnsanlar program yazarken programlama dili
ile savaşmak yerine kendilerini ifade etmek isterler. Bu
nedenle programlama dilleri, programcılara doğal
görünmelidir. Ben, Ruby’i tasarlarken sürprizleri en aza
indirgemeye çalıştım ve bundaki amacım program
yazarken harcanan eforu en aza indirgemekti.”.
Özgürlük ve Rahatlık Prensibi: Yazılım geliştiricilerin
geçmişte farklı programlama dillerini kullanmış olmaları,
farklı metodolojileri benimsemeleri ve hatta farklı
kültürlerden gelmeleri gayet olağan bir durumdur. Tüm
bunlardan dolayı her programcının kendine has sorun
çözme yöntemlerinin olması da kaçınılmazdır. Bu durumu
göz önünde bulunduran Ruby, programcıların kendilerini
özgür ve rahat hissetmeleri adına çoğu zaman alternatif
yollar sunar.
Maksimum Eğlence Prensibi: Program yazmanın genelde
zor ve sıkıcı bir iş olduğu söylenir. Halbuki hepimizin
diğer hayat amaçlarının yanı sıra eğlenmeye de ihtiyacının
olduğunu söyleyebiliriz. Ruby programcının sıkıcı
işlemler ile uğraşmak yerine sadece o anda yapılması
gereken asıl işe odaklanabilmesine imkan tanır. Diğer
dillerde satırlarca ifade ile yaptığınız bir işlemi Ruby ile
bir veya iki satırda halledebilirsiniz.

• Tamamen nesne yönelimli bir dildir: Ruby,
tamamen nesne yönelimli bir dil olarak
tasarlanmıştır. Ruby içerisinde her şey bir
nesnedir ve kendisine ait özellikleri ve metotları
bulunmaktadır. Programcının fazladan bir şeyler
yapmasına gerek duyulmadan “sarmalama”
ilkesinin gereği olarak nesnelere ait özelliklerin
ve metotların dış ortamdan gizlenmesine imkân
tanır.
• Çok sayıda programlama paradigmasını
destekler: Ruby nesne yönelimli özelliklerinin
yanında fonksiyonel, zorunlu (imperatif) ve
yansıtıcı (reaktif) programlama paradigmalarını
da destekleyen bir yapıya sahiptir.
• Yorumlanan bir dildir: Yorumlanan programlama
dillerinde yazılmış olan bir kodun çalıştırılması
bilgisayarda yer alan yorumlayıcı adında bir
yazılım sayesinde gerçekleştirilir. Bu yazılım
derlenen dillerin aksine kodumuzun tamamını tek
seferde makine diline dönüştürmek yerine; bu
dönüştürme işlemini satır satır
gerçekleştirmektedir. Yine derlenen dillerde
kodumuzda yapacağımız en ufak bir değişiklik
bütün program kodunun tekrar derlenmesi
anlamına gelmektedir ki bu da geliştirme sürecini
oldukça yavaşlatmaktadır. Yorumlanan dillerde
ise bu durumun aksine yapılan değişiklik
herhangi bir zaman kaybına yol açmaz.
• Platform bağımsız bir dildir: Yorumlanan dillerin
en büyük artılarından birisi de makine kodunun
çalışma zamanında oluşturulması sayesinde
herhangi bir platforma bağlı kalma
zorunluluğunun ortadan kalkmasıdır. Yani Ruby
hemen hemen tüm platformlarda sorunsuz
çalışabilmektedir.
• Dinamik ve güçlü tiplemeli bir dildir: Ruby
çalışma zamanında değişkenlerin tipini kendi
başına belirleyebilmektedir. Böylece herhangi bir
tip tanımlamasına ihtiyaç duyulmamaktadır.
Ayrıca programın çalışması sırasında bir
değişkene atanan değer veya bir metodun geriye
döndürdüğü değer gibi tipler de değiştirilebilir.
Ruby veri türleri konusundaki bu üstün
esnekliğinin yanında hatalı kullanımın da önüne
geçebilmek adına güçlü tipleme sistemi
kullanmaktadır. Bu sayede birbiriyle işleme
sokulamayacak olan bazı tipler arasında işlem
yapılması gibi hataların oluşması da
engellenmektedir.

Ruby birbirinden farklı pek çok alan için en uygun
dillerden birisidir. Ruby gerçek dünyada: internet tabanlı
uygulamalar, yapay zeka ve keşifsel matematik, CGI
programlama, GUI (Grafiksel Arayüz) uygulamaları, ağ
ve telekomünikasyon uygulamaları, robotik, sistem
programlama, güvenlik uygulamaları, metin işleme
yazılımları, genel programlama ve programlama eğitimleri
gibi alanlarda başarıyla kullanılmaktadır. Bu alanlarda
geliştirilen uygulamalara birkaç örnek vermek gerekirse:
NASA simülasyon uygulamalarının yönetilmesi, Motorola
simülatör uygulamasının geliştirilmesi, Google SketchUp
3D modelleme uygulamasının makro geliştirme API’si
geliştirilmesi, MORPHA projesinde, Siemens servis
robotunun reaktif denetim kısmının uygulaması ve Open
Domain Server IP ayarlarının gerçek zamanlı olarak
güncellenmesini ve böylece statik domainler ile
eşlenebilmesini sağlayan “Dynamic DNS” istemcilerinin
yazılması sırasında Ruby dilini kullanması örnek
verilebilir.

Ruby dilinin söz dizimine ilişkin temel kuralları
şöyle özetleyebiliriz:
• Bir Ruby programı art arda gelen ifadelerden
oluşur. İfadeleri birbirinden ayırmak için yeni
satır veya noktalı virgül karakteri kullanılabilir.
Bir ifade birden fazla satıra bölünmek istenirse;
bir önceki satır +, gibi sağ taraftaki operandı
eksik bir metot ile ya da ters bölü (\) karakteri ile
bitirilebilir.
• Boşluk karakterleri (space, tab gibi) sadece metin
türünden verilerin içerisinde yer aldıklarında
önem arz ederler, bunun dışında Ruby bu
karakterleri görmezden gelir.
• Diyez (#) karakteri ile başlayan metinler o satırın
sonuna kadar, =begin ve =end ifadeleri arasında
yer alan satırlar ise tamamıyla yorum satırlarıdır
ve Ruby yorumlayıcısı tarafından görmezden
gelinir.
• Değişken, metot veya sabitler gibi belirteçler
büyük-küçük harf duyarlıdır. Yani; AOF ile aof
tamamen farklı belirteçlerdir.
• Çeşitli amaçlarla Ruby dilinin kendisi tarafından
kullanılan kelimelere anahtar kelimeler denir. Bu
kelimeler değişken veya sabit isimleri olarak
kullanılamaz.
• Parantez karakterlerinin kullanımı çoğu durumda
isteğe bağlıdır. Bu özellik genellikle kodun daha
doğal görünmesini sağlarken; bazı zorunlu
durumlarda(örneğin aritmetiksel işlemlerdeki
işlem önceliğinin ayarlanması gibi) ve
karmaşıklık yaratabilecek hallerde kullanılması
gereklidir.

Değişkenleri birtakım verileri isimlendirmek ve
daha sonra bu isimle onlara erişmek için kullanmaktayız.
Tüm veriler çeşitli veri tiplerinde (metin, sayı, vb.)
bulunduklarından dolayı bazı programlama dillerinde bu
verilerin hangi türden olduğunun belirtilmesi gereklidir.
Ruby ise bu konuda oldukça esnektir; değişkenin türünü
kendisi belirler ve onunla ilgili işlemleri kendisi yaparak
bizi bu zahmetten kurtarır. Yine bazı dillerde değişkenler
kullanılmadan önce tanımlanmalıdır. Ruby dilinde ise bir
değişkene değer atandığı anda o değişken otomatik olarak
tanımlanmaktadır. Bir örnek ile bunu şöyle gösterebiliriz:
plaka = 26
plaka = “Eskişehir”

• Yerel Değişkenler: Sadece tanımlandıkları blok
içerisinde kullanılabilirler.
• Global Değişkenler: Tüm program içerisinde
kullanılabilir durumda olan değişkenlerdir. Bu
değişkenlerin isimlendirilmesine $ karakteri ile
başlanır.
• Örnek Değişkenleri: Nesnelere ait özellikleri
saklamak için kullanılır. Değişken ismi @
karakteri ile başlamalıdır.
• Sınıf Değişkenleri: Bir sınıf içerisinde veya bu
sınıftan oluşturulan tüm nesneler tarafından
erişilebilir olan değişkenlerdir. Sınıf değişkenleri
gibi her nesne için farklı bir değer taşımazlar,
sadece tek bir değerleri olabilir. Yazımına @@
karakterleri ile başlanmalıdır.
• Sabitler: Yerel değişkenler gibidirler ancak
değerleri değiştirilmeye çalışıldığında bir uyarı
alınmasına neden olurlar. Değeri program
boyunca değişmeyecek olan veriler için
kullanılmalıdırlar. İsimleri büyük harf ile
başlamalıdır. Ruby’de bazı yerlerde (sınıf ismi,
modül ismi gibi) sabitlerin kullanılması
zorunludur.

Ruby dilinde kullanılan veri türlerini basit veri
türleri (sayılar, metinler, semboller ve mantıksal) ve
birleşik veri türleri (diziler ve sözlükler) olarak ikiye
ayırabiliriz.
Sayılar: Ruby dilinde diğer pek çok dilde olduğu gibi
temel olarak iki tür sayı bulunmaktadır: tamsayılar ve
ondalık sayılar. Bu türlerin yanı sıra rasyonel sayılar,
karmaşık sayılar gibi sıra dışı sayı türlerine de bütünleşik
olarak destek sunulmaktadır.
Metinler: Metinler tek veya çift tırnak karakterleri arasına
yazılmış karakter dizileridir: “Merhaba”, “213. Sokak”,
‘34+65’, “Anadolu Üniversitesi” gibi. Sayılarda olduğu
gibi metinlerle birlikte de kullanabileceğimiz pek çok
metot bulunmaktadır.
Semboller: Ruby içerisinde metinlere oldukça benzeyen
sembol adında bir veri türü daha bulunmaktadır.
Sembollerin metinlerden farkı bir kere oluşturulduklarında
program boyunca aynı bellek bölgesini işgal etmeleridir.
Oysa metinler aynı içeriğe sahip olsalar dahi her
kullanıldıklarında tekrar oluşturulmaktadır. Bu da bellek
kullanım miktarını ve performansı bir miktar
düşürmektedir. Bu nedenle programımızda sık
kullanacağımız metinleri sembol haline dönüştürmek
yararlı olacaktır. Sembollerin oluşturulması da metinlere
oldukça benzerdir; tek farkı sembollerin başında iki nokta
üst üste “:” karakterinin yer almasıdır.
Mantıksal: Çoğu programlama dilinde olduğu gibi
Ruby’de de mantıksal veri türleri yer almaktadır. Bunlar
doğru, evet, ikilik sistemde 1 rakamı gibi değerleri temsil
etmek için true, yanlış, hayır ve 0 rakamını temsil etmek
için false ve hiçbir verinin olmaması durumunu temsil
etmek için kullanılan nil yapılarıdır. Bu yapılar akış
kontrolü sağlanması konusunda kullanışlıdır.
Diziler: Diziler, sıralı listelerden başka bir şey değildir.
Tıpkı metinlerde bahsettiğimiz gibi dizilerde de indisler
sıfır rakamı ile başlar. Bir dizinin elemanları temel veri
türlerinden olabileceği gibi; başka bir dizi veya sözlük
olabilir. Bir dizi oluşturmak için çok sayıda olası yoldan
bahsedebiliriz ancak bunların içerisinde en basit ve kolay
anlaşılabilir olanı [ ] karakterlerinin kullanılmasıdır.
Sözlükler: Sözlükler de tıpkı diziler gibi bir liste yapısıdır.
Aralarındaki en temel fark; bir dizinin elemanlarına
erişmek için indisleri kullanmamız gerekirken, sözlüklerde
bunun yerine onlara vermiş olduğumuz isimleri, diğer bir
deyişle anahtar değerleri kullanırız. Diğer bir fark ise
sözlükler oluştururken kullandığımız [ ] karakterleri yerine
{ } karakterlerini kullanmamız gerektiğidir.

Metotlar nesne yönelimli programlamada oldukça
önemli bir yere sahip olmalarının yanında, NYP
kullanılmasa dahi programlarımızda aynı kod bloğunu
olduğu gibi veya farklı parametrelerle bir defadan fazla
çalıştırmamız gerektiğinde de oldukça kullanışlı yapılar
olarak karşımıza çıkmaktadır. Ruby’de metot
tanımlamaları def anahtar kelimesi ile başlar ve end
anahtar kelimesi ile biter.
Bir metodun oluşturulması, o metot içerisinde
tanımlananların yerine getirilmesi anlamına gelmez.
Metodun işini yerine getirebilmesi için ona bir çağrı
gönderilmesi, yani çağırılması gerekmektedir. Bir metodu
çağırmak için ismini yazmamız yeterli olacaktır.

Bloklar, ruby içerisinde oldukça sık kullanılan
yapılardır. Blokları isimsiz metotlar olarak düşünebiliriz
ki; metotlarda olduğu gibi bu yapıları da genellikle aynı
işlemin tekrarlanması veya farklı bir noktada kullanılması
amacıyla kullanmaktayız. Bununla birlikte bir bloğun tek
başına kullanımı sık karşılaşabileceğimiz bir durum
değildir. Ruby içerisinde bloklar, bir metoda parametre
olarak gönderilmekte ve çalışmaları sağlanmaktadır.
Bir bloğun başlangıç ve bitiş noktalarını belirtmek için do
ve end anahtar kelimelerini kullanırız. Bu amaçla süslü
parantezleri de kullanabiliyor olsak da, bu kullanım şekli
bloğun içeriğinin bir satırdan uzun olması durumunda pek
tercih edilmemektedir.

Ruby ile geliştirilen uygulamalara ekstra
özellikler ve işlevsellik katmak amacıyla kullandığımız
paketlere “gem” adını vermekteyiz. Bu paketleri yönetmek
için kullandığımız uygulamaya ise RubyGems
denilmektedir. Ruby yüklemesi ile birlikte zaten
sistemimize kurulmuş olan RubyGems paket yöneticisi
aşağıda gösterildiği şekilde kullanılabilir:
$: gem install paket_adi
Yüklü paketi son sürümüne güncellemek için:
$: gem update paket_adi
Bir paketi sistemimizden kaldırmak için:
$: gem uninstall paket_adi
komutlarını terminal üzerinde çalıştırabiliriz.

Ruby on Rails, Ruby dili ile geliştirilmiş bir web
uygulama geliştirme çatısıdır (framework). İnternet tabanlı
uygulamalarda ihtiyaç duyulabilecek şeylere ilişkin
varsayımlar kullanarak, uygulamaların çok kısa sürede ve
kolayca geliştirilmesine imkan tanımaktadır. Bu sayede az
kodla, çok iş yapılması mümkün olmaktadır. Rails
felsefesi ya da daha çok bilinen ismiyle Rails yolu iki ana
prensibi benimsemektedir:
1. Kendi Kendini Tekrarlama: DRY(Don’t Repeat
Yourself) olarak bilinen bu prensip; her bilgi
parçasının bir sistem içerisinde tek, kesin ve
güvenilir bir ifadesinin olması gerektiğini
savunmaktadır. Aynı bilginin tekrar tekrar
yazılmıyor olması kodumuzun daha yönetilebilir,
esnek ve az hatalı hale gelmesini sağlayacaktır.
2. Konfigürasyon Üzerine Kabuller: Rails, bir web
uygulamasında gerekli olan pek çok şeyi yapmak
için kullanılabilecek en iyi yolun hangisi
olduğuna ilişkin fikirlere sahiptir ve bunu
varsayılan olarak sunmaktadır. Bu sayede
programcılar, sonsuz konfigürasyon ayarlamaları
ile uğraşmak yerine; ya hiç ya da çok az
değişikliğe ihtiyaç duyacaklardır.

MVC, çevik(agile) yazılım geliştirme süreçlerine
uygun olarak sıklıkla tercih edilen bir yazılım mimarisi
desenidir. İlk olarak 1979 yılında SmallTalk programlama
dili ile birlikte ortaya çıkmış olan MVC’nin ardındaki ana
düşünce; yazılımın kullanıcıya hitap eden bölümü yani
kullanıcı arayüzü ile arka plandaki işlemlerin birbirinden
ayrı bölümler olarak ele alınmasına dayanmaktadır. Bu
amaçla sistemi üç ana rol başlığı altında geliştirmeyi
öngörmektedir:
• Model: Uygulamaya özel verilerin ve
uygulamanın iş mantığına uygun biçimde bu
veriler arasındaki ilişkilerin, erişim ve düzenleme
kurallarının bulunduğu bölümdür. Diğer bir
deyişle uygulamamızın kullandığı tüm verilerin
yaşadığı yer burasıdır. Model, bu verilerin
kullanıcıya ne şekilde sunulacağı ile ilgilenmez.
• View (Görünüm): Uygulamanın kullanıcılarına
sunulacak olan arayüz elemanlarını içeren yani
kullanıcıların gördüğü yegane bölümdür.
Kullanılan verilerin nereden geldiği ile ilgili bir
bilgisi yoktur.
• Controller (Kontrolör): Kullanıcıdan gelen
isteklerle ilgili işlemleri gerçekleştirmek üzere
gerekli görevleri yerine getiren bölümdür.
Uygulamayı kullanan kişi ne zaman bir istekte
bulunacak olsa, bu isteği ele alacak olan bölüm
burasıdır. İsteğe uygun olarak gerekli yanıtı
(genellikle uygun verilerle birlikte bir görünüm
oluşturarak), istemciye ulaştırmakla yükümlüdür.
MVC kullanan standart bir uygulamada çok sayıda model,
görünüm ve kontrolör bulunur. Bu bölümler arasındaki
ilişki; aracı rolünü oynayan kontrolör tarafından
gerçekleştirilmektedir. Yani model ve görünüm arasında
doğrudan bir ilişki söz konusu değildir. Eğer uygulamamız
bir veri tabanı kullanmaktaysa; veri tabanına erişmekle
yükümlü olan bölüm modeldir. Kullanıcı, görünümleri
kullanarak veya doğrudan bir istek yaptığında, bu istek
kontrolöre iletilir. Bu isteğe karşılık olarak, kontrolör
gerekliyse model ile iletişime geçtikten sonra kullanıcıya
sunulacak görünümü oluşturur ve oluşturulan bu görünüm
kullanıcıya sunulur.

1. Bir istemcinin uygulamamız ile iletişime geçmesi
sırasında gerçekleşecek olan ilk adım, sunucudan
bir HTTP isteğinde bulunulmasıdır. Bir HTTP
isteği kaynağın URL adresi, istek metodu ve
başlık bilgilerinden oluşur.
2. İsteği alan sunucu, onu Action Dispatch
bileşenine iletir. Bu bileşen, istenilen kaynağa
ilişkin URL adresi ile uygulamanın rota
tablosunda yer alan kayıtları karşılaştırır.
Eşleşme bulması durumunda bu rotaya karşılık
olarak belirtilmiş olan kontrolöre ilişkin eylemi
çalıştırır ve (varsa) parametreleri de gönderir.
Böylece kontrol Action Controller bileşenine
geçer.
3. Eylemin çalıştırılması sırasında veri tabanı ile
etkileşim gerekliyse; Action Controller bileşeni,
Active Record bileşeni ile etkileşime geçer ve bu
bilesen veri tabanındaki gerekli işlemleri
gerçekleştirir.
4. Action Controller daha sonra kontrolü Action
View bileşenine devrederek görünümlerin
oluşturulmasını sağlar. Oluşturulan görünümler
tekrar Action Controller bileşenine iletilir.
5. İletişimin son adımı da HTTP yanıtının
oluşturularak, istemciye gönderilmesi olacaktır.
Bu adımda; Action Controller, Action View’dan
gelen çıktıyı (HTML, XML, JSON gibi) mesajın
gövdesine ekleyerek, diğer bilgilerle (baslık
bilgileri, durum kodu) beraber web sunucusuna
gönderir. Web sunucusu da tüm bunları
tarayıcıya gönderir ve süreç tamamlanır.

Ruby yüksek okunabilirliğe sahip olması, esnek kod yazmaya imkân tanıması, kolaylıkla genişletilebilmesi, platform bağımsız olması gibi pek çok nedenden ötürü günümüzün popüler dilleri arasında yer almaktadır.

Perl, Pyhton, SmallTalk, Ada gibi pek çok programlama dilinden esinlenmiş olan Ruby, aynı zamanda Rust, Swift, Clojure, Crystal gibi birçok programlama diline de esin kaynağı olmuştur.

• İnsan Faktörü Prensibi
• Asgari Sürpriz Prensibi
• Özgürlük ve Rahatlık Prensibi
• Maksimum Eğlence Prensibi

Tamamen nesne yönelimli bir dildir.

Çok sayıda programlama paradigmasını destekler.

Yorumlanan bir dildir.

Platform bağımsız bir dildir.

Dinamik ve güçlü tiplemeli bir dildir.

Ruby kodunu çalıştırmak için komut satırı üzerinden Ruby Yorumlayıcısını (MRI) veya Etkileşimli Ruby (IRB) yazılımını kullanabiliriz.

Bir programlama dili için söz dizimi; o dilin yapıları kullanılarak geçerli bir ifadenin nasıl oluşturulabileceğine ilişkin konuları kapsamaktadır.

Yerel Değişkenler

Global Değişkenler

Örnek Değişkenleri

Sınıf Değişkenleri

Sabitler

Ruby dilinde kullanılan veri türlerini basit veri türleri (sayılar, metinler, semboller ve mantıksal) ve birleşik veri türleri (diziler ve sözlükler) olarak ikiye ayırabiliriz.

Örnekteki .. ve ... karakterlerinin kullanımına aralık (range) adını vermekteyiz. Aralık belirtirken iki nokta kullandığımızda son karakter aralığa dahil olurken, üç nokta kullanımında son karakter aralığa dahil edilmemektedir.

Terminal ekranına bir şeyler yazdırmak amacıyla puts veya print metodu kullanılabilir. puts metodu yazma işleminden sonra yeni satıra geçerken, print metodu aynı satırdan devam etmektedir.

Metinler içerisinde “, ‘, \ gibi özel karakterler kullanılmak istenirse; bu karakterler kaçış karakteri adı verilen \ karakterinden sonra yazılmalıdır.

Aralarındaki en temel fark; bir dizinin elemanlarına erişmek için indisleri kullanmamız gerekirken, sözlüklerde bunun yerine onlara vermiş olduğumuz isimleri, diğer bir deyişle anahtar değerleri kullanırız. Diğer bir fark ise sözlükler oluştururken kullandığımız [ ] karakterleri yerine { } karakterlerini kullanmamız gerektiğidir.

Ruby içerisinde metinlere oldukça benzeyen sembol adında bir veri türü daha bulunmaktadır. Sembollerin metinlerden farkı bir kere oluşturulduklarında program boyunca aynı bellek bölgesini işgal etmeleridir. Oysa metinler aynı içeriğe sahip olsalar dahi her kullanıldıklarında tekrar oluşturulmaktadır. Bu da bellek kullanım miktarını ve performansı düşürmektedir. Bu nedenle programımızda sık kullanacağımız metinleri sembol haline dönüştürmek performans kaybını azaltmak için gereklidir.

Bir metot isminin son harfinin “?” olması; bu metodun geriye true veya false bir değer döndürdüğü anlamına gelmektedir:

# Tek sayı mı?

12.odd? #=> false

13.odd? #=> true

Yukarıdaki kod parçasında Bilgisayar isminde bir sınıf tanımladık. Sınıfa ait özellikleri belirtirken attr_accessor isimli ön tanımlı bir metottan yararlandık. Bu metot islemci ve bellek isminde iki özellik ve bu özelliklere aynı isimlerle erişmemizi sağlayan ikişer metodu da bizim için tanımlamış oldu. 

Ruby ile geliştirilen uygulamalara ekstra özellikler ve işlevsellik katmak amacıyla kullandığımız paketlere “gem” adını vermekteyiz. Bu paketleri yönetmek için kullandığımız uygulamaya ise RubyGems denilmektedir.

• Kendi Kendini Tekrarlama: DRY(Don’t Repeat Yourself) olarak bilinen bu prensip; her bilgi parçasının bir sistem içerisinde tek, kesin ve güvenilir bir ifadesinin olması gerektiğini savunmaktadır. Aynı bilginin tekrar tekrar yazılmıyor olması kodumuzun daha yönetilebilir, esnek ve az hatalı hale gelmesini sağlayacaktır.
• Konfigürasyon Üzerine Kabuller: Rails, bir web uygulamasında gerekli olan pek çok şeyi yapmak için kullanılabilecek en iyi yolun hangisi olduğuna ilişkin fikirlere sahiptir ve bunu varsayılan olarak sunmaktadır. Bu sayede programcılar, sonsuz konfigürasyon ayarlamaları ile uğraşmak yerine; ya hiç ya da çok az değişikliğe ihtiyaç duyacaklardır.

MVC, çevik(agile) yazılım geliştirme süreçlerine uygun olarak sıklıkla tercih edilen bir yazılım mimarisi desenidir. İlk olarak 1979 yılında SmallTalk programlama dili ile birlikte ortaya çıkmış olan MVC’nin ardındaki ana düşünce; yazılımın kullanıcıya hitap eden bölümü yani kullanıcı arayüzü ile arka plandaki işlemlerin birbirinden ayrı bölümler olarak ele alınmasına sağlamaktadır.

• Model: Uygulamaya özel verilerin ve uygulamanın iş mantığına uygun biçimde bu veriler arasındaki ilişkilerin, erişim ve düzenleme kurallarının bulunduğu bölümdür. Diğer bir deyişle uygulamamızın kullandığı tüm verilerin yaşadığı yer burasıdır. Model, bu verilerin kullanıcıya ne şekilde sunulacağı ile ilgilenmez.
• View (Görünüm): Uygulamanın kullanıcılarına sunulacak olan arayüz elemanlarını içeren yani kullanıcıların gördüğü yegane bölümdür. Kullanılan verilerin nereden geldiği ile ilgili bir bilgisi yoktur.
• Controller (Kontrolör): Kullanıcıdan gelen isteklerle ilgili işlemleri gerçekleştirmek üzere gerekli görevleri yerine getiren bölümdür. Uygulamayı kullanan kişi ne zaman bir istekte bulunacak olsa, bu isteği ele alacak olan bölüm burasıdır. İsteğe uygun olarak gerekli yanıtı (genellikle uygun verilerle birlikte bir görünüm oluşturarak), istemciye ulaştırmakla yükümlüdür.

Rails yönlendiricisi ile birlikte kullanabileceğimiz HTTP metotları GET, POST, PUT, PATCH ve DELETE olmak üzere beş adettir. GET metodu ile yapılan istekler sunucudaki bir kaynağı elde etmek için kullanılır.POST metodu sonucunda sunucuda yeni bir kaynak oluşturulması hedeflenmektedir. Sunucudaki bir kaynağın güncellemesi amacıyla kullanılabilecek olan PUT ve PATCH metotlarından ilki kaynağın tamamıyla güncellenmesi durumunda kullanılırken, patch metodu kaynağın kısmen güncellenmesinin istenildiğini gösterir. DELETE metodu ile yapılan istekler ise sunucudaki bir kaynağın silinmesini hedef almaktadır.