Giriş: Programlama paradigmaları neden önemli?

Bir yazılım projesinde paradigma, veri ve davranışların nasıl yapılandırılacağını, kodun nasıl test edileceğini ve ekip içi sorumlulukların nasıl dağıtılacağını belirler. Nesne Yönelimli Programlama (OOP) ve Fonksiyonel Programlama (FP) iki farklı yaklaşım sunar; her biri farklı problemlere daha uygun olabilir. Aşağıda her iki paradigmanın temel ilkelerini, güçlü ve zayıf yönlerini ve pratik JavaScript/Python örneklerini bulacaksınız.

Temel kavramlar

Nesne Yönelimli Programlama (OOP)

OOP, veriyi (state) ve veri üzerinde işlem yapan fonksiyonları (davranış) nesneler içinde birleştirerek gerçek dünya kavramlarını modellemeyi amaçlar. Bu yaklaşımla sınıf (class) ve örnek (object) kavramları ön plana çıkar. OOP hakkında temel bilgiler için bkz. Patika.dev — OOP Nedir? (kaynak).

• Enkapsülasyon: Verinin ve onu değiştiren işlevlerin birlikte paketlenmesi, dışarıdan doğrudan erişimin sınırlandırılması.
• Miras (Inheritance): Bir sınıfın başka bir sınıftan özellik ve davranış devralması.
• Polimorfizm: Aynı arayüzün farklı sınıflarda farklı davranması.
• Soyutlama: Karmaşıklığı gizleme ve önemli olanı öne çıkarma.

Fonksiyonel Programlama (FP)

FP, hesaplama birimi olarak fonksiyonları ön plana çıkarır. FP'de saf (pure) fonksiyonlar, değişmez veri yapıları (immutability) ve yan etkilerin (side effects) minimize edilmesi temel ilkeler arasındadır. Temel prensiplere bir giriş için bkz. KodSözlük — Fonksiyonel Programlama Nedir?.

• Saf fonksiyonlar: Aynı girdi için her zaman aynı çıktıyı verir ve yan etki üretmez.
• İmmutability: Veri değiştirilmeyip, değişiklik gerekiyorsa yeni bir kopya döndürülür.
• Yüksek dereceli (higher-order) fonksiyonlar: Fonksiyonları argüman ya da dönüş değeri olarak kullanma.
• Fonksiyon bileşimi: Küçük fonksiyonları birleştirerek daha karmaşık işlemler oluşturma.

Hızlı karşılaştırma tablosu

Pratik kod örnekleri

Aşağıdaki örnekler aynı problemi OOP ve FP yaklaşımlarıyla nasıl çözebileceğinizi gösterir. Kodlar basit tutulmuştur; üretim kodu için ek doğrulama ve hata yönetimi eklenmelidir.

JavaScript örnekleri

OOP — Basit Sepet sınıfı
class Cart {
constructor(items = []) { this.items = items; }
addItem(item) { this.items.push(item); }
total() { return this.items.reduce((s, i) => s + i.price, 0); }
}
// Kullanım
const cart = new Cart();
cart.addItem({ name: 'elma', price: 1 });
console.log(cart.total());

FP — Değişmez ve saf fonksiyonlar
const addItem = (cart, item) => [...cart, item];
const total = cart => cart.reduce((s, i) => s + i.price, 0);
const cart1 = [];
const cart2 = addItem(cart1, { name: 'elma', price: 1 });
console.log(total(cart2)); // cart1 değişmedi

JS örnekleri, dilin hem sınıf tabanlı hem de fonksiyonel yaklaşımları desteklediğini gösterir; fonksiyonel örnekte yan etkiler yoktur ve veri değişmeden yeni dizi döndürülür.

Python örnekleri

OOP — Basit Banka Hesabı
class Account:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = balance
def deposit(self, amount):
self._balance += amount
return self._balance
def withdraw(self, amount):
if amount > self._balance:
raise ValueError('Yetersiz bakiye')
self._balance -= amount
return self._balance
def balance(self):
return self._balance
acc = Account('Ayşe', 100)
acc.deposit(50)

FP — İmmutability ile dataclass örneği
from dataclasses import dataclass, replace
@dataclass(frozen=True)
class AccountData:
owner: str
balance: float = 0.0
def deposit(account, amount):
return replace(account, balance=account.balance + amount)
def withdraw(account, amount):
if amount > account.balance:
raise ValueError('Yetersiz bakiye')
return replace(account, balance=account.balance - amount)
acc1 = AccountData('Ayşe', 100)
acc2 = deposit(acc1, 50) # acc1 değişmez, acc2 yeni nesnedir

Python örnekleri aynı işlevi gösterir: OOP durum yönetimi nesnede tutarken, FP örneğinde yeni immutable nesneler oluşturulur. Her iki yaklaşım da kullanılabilir; seçim gereksinimlere bağlıdır.

Ne zaman hangi paradigmayı tercih etmelisiniz? — Pratik rehber

• OOP tercih edin: Karmaşık domain modelleri, zengin nesne etkileşimleri ve uzun süreli bakım gerektiren büyük uygulamalar için uygundur (örnek kaynak: Patika.dev ve Kodlama Vakti).
• FP tercih edin: Veri dönüşümleri, paralel işleme, pipeline tabanlı hesaplamalar ve test edilebilirlik ön planda olduğunda avantajlıdır (inceleme).
• Hibrit yaklaşım: Çoğu modern uygulama hem OOP hem FP tekniklerini birleştirir; domain modeller OOP ile, veri işleme fonksiyonları FP ile yazılabilir.

Seçim kontrol listesi

• Uygulama domaini nesne tabanlı mı yoksa veri dönüşümleri mi yoğun? (domain → OOP, veri yoğun → FP)
• Ekip deneyimi hangi paradigmada daha fazla?
• Concurrency veya paralel işleme gereksinimi var mı? (FP fayda sağlayabilir)
• Test edilebilirlik ve sürdürülebilirlik hedefleri nelerdir?

Geçiş stratejileri — adım adım

1. Kritik yol fonksiyonlarını saf fonksiyonlara çevirin (yan etkileri sınırlandırma).
2. Global ve paylaşılan mutable state kullanımını azaltın; gerektiğinde kapsülleyin.
3. Yavaş yavaş küçük modüllerde immutable veri yapıları kullanın.
4. Ekip içinde kod inceleme kurallarına FP prensiplerini ekleyin (ör. saf fonksiyon tercihleri).

Özet: Nesne Yönelimli ve Fonksiyonel paradigmalar farklı problemlere farklı avantajlar sunar. OOP, büyük domain modelleme ve nesne ilişkileri için güçlüdür; FP ise yan etkileri azaltarak test edilebilirlik ve paralel işlem avantajı sağlar. Genellikle en iyi yaklaşım proje gereksinimlerine göre her iki paradigmanın güçlü yönlerini birleştirmektir.

Kaynaklar ve ileri okumalar

• Patika.dev — Nesne Yönelimli Programlama
• KodSözlük — Fonksiyonel Programlama
• Hostragons — Paradigmalar Karşılaştırması
• Kodlama Vakti — OOP açıklaması

Bu kaynaklar makaledeki temel iddiaları ve kavramları desteklemektedir.