Clean Code (Temiz Kod) Prensipleri

Bir yazılım projesinde temiz kodun önemi, etkileri ve nasıl uygulanacağı hakkındaki yazıma hoşgeldiniz, iyi okumalar.

Temiz kod, esasında karmaşıklığı önlemeyi ve yazılımın uzun vadeli sürdürülebilirliğini artırmayı hedefler. Kodu daha okunabilir, test edilebilir ve daha az hataya eğilimli hale getirmek için tasarlanmış bir dizi ilkeyi takip eder. Temiz kodun temel ilkelerinden bazıları şunlardır:

Netlik: Kodun okunması ve anlaşılması kolay olmalıdır.
Basitlik: Kod, gereksiz karmaşıklıktan kaçınarak mümkün olduğunca basit olmalıdır.
Yorumlar: Yorumlar az kullanılmalı ve yalnızca karmaşık veya açık olmayan kodu açıklamak için gerekli olduğunda kullanılmalıdır.
Adlandırma: Değişkenler, fonksiyonlar ve sınıflar anlamlı ve açıklayıcı isimlere sahip olmalıdır.
Biçimlendirme: Kod, okunabilirliği artırmak için tutarlı bir şekilde biçimlendirilmelidir.
İşlevsellik: Kod küçük, tek amaçlı fonksiyonlar ve sınıflar halinde düzenlenmelidir.
Hata işleme: Kod, hataları tutarlı ve öngörülebilir bir şekilde ele almalıdır.
Test etme: Kod test edilebilir olmalı ve yüksek test kapsamına sahip olmalıdır.
Yeniden kullanılabilirlik: Kod yeniden kullanılabilir ve modüler olacak şekilde tasarlanmalıdır.
Performans: Kod verimli ve performanslı olacak şekilde tasarlanmalıdır.

Bu ilkeleri detaylı anlatmaya geçmeden önce sizlere neden temiz kod yazmamız gerektiğini ve yazılım camiasındaki popüler isimlerin temiz kod hakkındaki fikirlerini aktarmak istiyorum.

Temiz kod, aslında kötü kodun (bad code) önlenmesini amaçlar, bunun en temel nedeni yazılımın yaşam süreci boyunca geliştiricilere ve sahiplerine olan maliyetinin azaltılması, değiştirilmeye ve geliştirilmeye elverişli bir yapıda olmasıdır. Her ne kadar geliştiriciler olarak bilgisayarların anlayacağı şekilde kod yazsakta aslında diğer geliştiricilerinde anlayacağı şekilde de yazmalıyız. Zamanla iş mantığını güncelledikçe veya yeni özellikler ekledikçe kodumuz aynı kalmayacak. Kodumuz diğer geliştiriciler tarafından da güncellenebilir. Bu nedenle kodu diğer geliştiricilerin de okuyup anlayabileceği şekilde yazmalıyız.

Temiz kod hakkında birkaç düşünce:

Bjarne Stroustrup, C++’ın mucidi:” Kod zarif ve verimli olmalıdır. En önemlisi bağımlılıkları minimum düzeyde olmasıdır. Kodun verimliliği hızından daha önemlidir.”

Robert C. Martin (Uncle Bob): “Kodunuzu yazarken kendi kendinize konuşuyormuş gibi düşünün. Kod, insanlar tarafından yazılmış olduğu kadar, insanlar tarafından okunacaktır.”

Kent Beck: “Kod kalitesi, müşteri değeri kadar önemlidir.”

Sandi Metz: “Kodunuzu daha az işlevsel hale getirmek, daha fazla iş yapabilir hale gelmesini sağlar.”

Michael Feathers, Eski Kodla Etkili Çalışma kitabının yazarı: “Temiz kod titiz çalışan bir yazılımcı tarafından yazılır ve daha iyi hale getirmek için yapılacak bir şey kalmamıştır.”

Örnekler

Örnekleri, aklınızda bir şeyler canlanması ve yer edinmesi amacıyla en basit şekilde yazmak istedim, burada çok kapsamlı bir rehber yazmak yerine konuyu özet ve ve küçük bir rehber olacak şekilde aktarmak istedim, unutmayın ki bir yazılımcının en büyük silahlarından biride araştırmaktır, yazdığınız kodları geliştirme amacıyla hareket eder ve bu minvalde adımlar atarsanız her bir ilkeyi zamanla kendi kodunuza entegre etmeyi zamanla alışkanlık haline getirirsiniz.

Netlik (Clarity):

Bu ilke, kodun okunması ve anlaşılmasının kolay olması gerektiğini vurgular. Örnekteki kod, y ve z’nin ortalamasını hesaplar ve bunu “average” adlı bir değişkene atar. Bu sayede kodun ne yaptığı açıkça anlaşılır.

# Yanlış
x = y + z / 2

# Doğru
average = (y + z) / 2

Basitlik (Simplicity):

Basitlik ilkesi, gereksiz karmaşıklıktan kaçınarak kodun mümkün olduğunca basit olmasını önerir. Örnekte karmaşık bir alışveriş sepeti işlevi daha basitleştirilmiş ve daha anlaşılır bir hale getirilmiştir. İlk fonksiyon, her bir öğe için ayrı ayrı işlemler yapmakta ve bu işlemleri bir döngü içinde gerçekleştirmektedir. Bununla birlikte, ikinci fonksiyon doğrudan toplam fiyatı hesaplamak için daha basit ve daha doğrudan bir yaklaşım kullanmaktadır. Bu şekilde kod, gereksiz karmaşıklıktan kaçınılarak daha basit ve anlaşılır hale getirilmiştir.

# Karmaşık bir şekilde yapılandırılmış bir alışveriş sepeti işlevi
def process_shopping_cart(items, discounts, tax_rate):
    total = 0
    for item in items:
        if item in discounts:
            total += items[item] * (1 - discounts[item])
        else:
            total += items[item]
    return total * (1 + tax_rate)

# Basit ve doğrudan bir şekilde yapılandırılmış alışveriş sepeti işlevi
def calculate_total_price(items, discounts, tax_rate):
    subtotal = sum(items.values())
    total_discount = sum(items[item] * discount for item, discount in discounts.items() if item in items)
    total_with_discount = subtotal - total_discount
    total_with_tax = total_with_discount * (1 + tax_rate)
    return total_with_tax

Yorumlar (Comments):

Örnekte, doğru olan, kodun amacını ve neyi hesapladığını açıklayan yorumların eklenmesidir. Bu sayede, kodu okuyanlar, fonksiyonun ne yaptığını daha kolay anlayabilirler. Ancak yanlış olan, yoruma eklenen açıklamanın gereksiz ve tekrarlayıcı olmasıdır.

# Yanlış
def calculate_salary(hours, hourly_rate):
    # Fonksiyon, saatlik ücret ve çalışılan saatlerin çarpımını hesaplar.
    result = hours * hourly_rate
    return result

# Doğru
def calculate_salary(hours, hourly_rate):
    # Maaş, çalışılan saatlerin saatlik ücretle çarpılmasıyla hesaplanır.
    salary = hours * hourly_rate
    return salary

Adlandırma (Naming):

Örnekte, doğru olan, fonksiyonun ne yaptığını açıklayan ve işlevini anlamak için yeterli olan açıklayıcı bir ismin kullanılmasıdır. calculate_double ismi, fonksiyonun bir sayının iki katını hesapladığını belirgin bir şekilde ifade eder. Ancak yanlış olan, fonksiyonun işlevini açıklamayan ve neyi hesapladığını belirtmeyen genel bir ismin kullanılmasıdır.

# Yanlış
def func(x):
    return x * 2

# Doğru
def calculate_double(x):
    return x * 2

Hata işleme (Error Handling):

Kod, hataları tutarlı ve öngörülebilir bir şekilde ele almalıdır. Örnekte, sıfıra bölme hatası oluştuğunda kodun sınırsızı temsil eden bir değer döndürmesi beklenen bir davranıştır, bu da hata işleme açısından öngörülebilir bir yaklaşımdır.

# Yanlış
try:
    result = x / y
except:
    result = None

# Doğru
try:
    result = x / y
except ZeroDivisionError:
    result = float('inf')

Yeniden kullanılabilirlik (Reusability):

Kod, yeniden kullanılabilir ve modüler olacak şekilde tasarlanmalıdır. Örnekte, bir dairenin alanını hesaplayan bir fonksiyon, başka programlarda veya modüllerde tekrar kullanılabilir.

# Yanlış
def calculate_area_of_circle(radius):
    return 3.14 * radius * radius

# Doğru
import math

def calculate_area_of_circle(radius):
    return math.pi * radius * radius

Okuyabileceğiniz birkaç kaynak:

Referanslar:

https://roadmap.sh/software-design-architecture
https://workat.tech/machine-coding/tutorial/introduction-clean-code-software-design-principles-nwu4qqc63e09