Döngüsel Karmaşıklık (Cyclomatic Complexity) Nasıl Hesaplanır?

Kod kalitesini konuşurken sıkça karşımıza çıkan kavramlardan biri "döngüsel karmaşıklık"tır. Kulağa matematiksel ve ürkütücü gelse de aslında oldukça basit bir fikre dayanır: bir kod parçasının içinde kaç farklı yürütme yolu olduğunu saymak. Bu yazıda, bu metriğin ne anlama geldiğini, nasıl hesaplandığını ve statik kod analizi araçlarıyla nasıl ilişkilendiğini sade bir dille ele alacağız.

Döngüsel Karmaşıklık Nedir?

Döngüsel karmaşıklık, bir fonksiyonun veya kod bloğunun içinde kodun izleyebileceği farklı yolların sayısını ölçen bir metriktir. Bir fonksiyon ne kadar çok "eğer şu olursa böyle yap, yoksa şöyle yap" gibi karar noktası içeriyorsa, o fonksiyonun karmaşıklığı da o kadar artar.

Bu metriğin kod kalite metrikleri arasında önemli bir yer tutmasının nedeni, karmaşıklığın doğrudan anlaşılabilirlik ve bakım kolaylığıyla ilişkili olmasıdır. Az sayıda karar noktası içeren bir fonksiyonu okumak ve ne yaptığını anlamak kolaydır. Ancak iç içe geçmiş çok sayıda koşul, döngü ve dallanma içeren bir fonksiyon, hem yeni katılan bir geliştirici için hem de kodu yazan kişinin kendisi için zamanla takip edilmesi zor bir yapıya dönüşebilir. Karmaşıklık arttıkça, olası hataları öngörmek ve kodu güvenle değiştirmek de zorlaşır.

Kontrol Akış Grafiği Mantığı: Basit Bir Benzetme

Döngüsel karmaşıklığın arkasındaki teknik temel, "kontrol akış grafiği" (control flow graph) adı verilen bir yapıdır. Bunu jargonsuz bir şekilde anlamak için kodu bir yol haritası gibi düşünebiliriz.

Bir fonksiyonun en baştan sona kadar tek bir düz yoldan ilerlediğini hayal edin — hiçbir koşul, döngü veya seçim olmadan. Bu, tek bir yolu olan düz bir caddeye benzer. Ancak koda bir if ifadesi eklediğinizde, yolda bir kavşak oluşur: kod artık ya bu yöne ya da öbür yöne gidebilir. Her yeni koşul, döngü veya seçim yapısı, bu yol haritasına yeni bir kavşak eklemek gibidir.

Kontrol akış grafiği, işte bu kavşakları ve yolları görsel olarak temsil eden bir diyagramdır. Döngüsel karmaşıklık, temelde bu diyagramdaki kavşak sayısına dayanarak hesaplanır. Diyagramı çizmek zorunda kalmadan da, koddaki karar noktalarını sayarak aynı sonuca ulaşabiliriz — bir sonraki bölümde bunu göreceğiz.

Temel Formül: Karar Noktaları + 1

Döngüsel karmaşıklığın hesaplanmasında matematiksel derinliğe inmeye gerek yok. Pratikte akılda tutulması gereken basit bir mantık var: her karar noktası, karmaşıklığı bir artırır.

Bir fonksiyonun hiçbir karar noktası yoksa (yani kod baştan sona düz bir şekilde ilerliyorsa), karmaşıklık değeri 1 kabul edilir. Bunun nedeni, kodun kendisinin zaten tek bir yürütme yolu oluşturmasıdır — bu, sayımın başlangıç noktasıdır. Ardından, kod içindeki her if, for, while, case gibi yapı birer karar noktası olarak sayılır ve toplam değere birer birer eklenir.

Yani basitleştirilmiş mantık şöyle özetlenebilir:

• Başlangıç değeri: 1
• Her if için: +1
• Her for veya while döngüsü için: +1
• Her case (switch içindeki her dal) için: +1
• Mantıksal and/or gibi bağlaçlarla birleşen koşullar için de genellikle ek birer artış sayılır (çünkü her biri ayrı bir değerlendirme yolu oluşturur)

Bu basit toplama mantığı, karmaşık formüllere girmeden bir fonksiyonun ne kadar "dallanmış" olduğunu tahmin etmemizi sağlar.

Örnek Kod Üzerinden Adım Adım Hesaplama

Kavramı somutlaştırmak için basit bir örnek üzerinden gidelim. Aşağıdaki gibi bir fonksiyon düşünelim (dil bağımsız, sözde kod olarak):

function siparisDurumu(siparis):
    if siparis.iptal_edildi:
        return "İptal Edildi"

    if siparis.odeme_yapildi:
        for urun in siparis.urunler:
            if urun.stokta_yok:
                return "Stok Bekleniyor"
        return "Hazırlanıyor"
    else:
        return "Ödeme Bekleniyor"

Şimdi bu fonksiyonu adım adım sayalım:

1. Başlangıç değeri: 1
2. if siparis.iptal_edildi → +1 (toplam: 2)
3. if siparis.odeme_yapildi → +1 (toplam: 3)
4. for urun in siparis.urunler döngüsü → +1 (toplam: 4)
5. if urun.stokta_yok → +1 (toplam: 5)

Bu fonksiyonun döngüsel karmaşıklığı toplamda 5 olur. Bu, fonksiyonun içinde beş farklı olası yürütme yolu bulunduğu anlamına gelir: iptal durumu, ödeme bekleniyor durumu, stok bekleniyor durumu, hazırlanıyor durumu gibi farklı senaryolar.

Fonksiyona yeni bir if veya case eklendikçe bu sayı artmaya devam eder. Bu da bize fonksiyonun büyüdükçe ne kadar hızlı karmaşıklaşabileceğine dair somut bir fikir verir.

Düşük ve Yüksek Değerler Ne Anlama Gelir?

Genel olarak düşük döngüsel karmaşıklık değerleri, fonksiyonun daha az dallanma içerdiğini, dolayısıyla daha okunabilir ve test edilebilir olduğunu gösterir. Az sayıda yürütme yolu olan bir fonksiyonu anlamak ve test etmek görece kolaydır.

Yüksek değerler ise genellikle "dikkat edilmesi gereken" bir sinyal olarak yorumlanır. Fonksiyon çok fazla karar noktası içeriyorsa, hem okunması hem de tüm olası senaryoların test edilmesi zorlaşır. Bununla birlikte, "şu sayıdan sonrası kesinlikle kötüdür" gibi kesin bir evrensel eşik yoktur; farklı statik analiz araçları kendi varsayılan eşik değerlerini belirler ve bu değerler araçtan araca değişebilir [kaynak gerekli]. Bu nedenle bir eşik sayısını mutlak bir kural olarak değil, ekibin ve projenin bağlamına göre değerlendirilmesi gereken bir gösterge olarak ele almak daha sağlıklıdır. Bazı projelerde belirli bir eşiği aşan fonksiyonlar otomatik olarak "gözden geçirilmesi gerekenler" listesine alınırken, bu eşik başka bir ekipte farklı olabilir.

Test Kapsamı ve Hata Riskiyle İlişkisi

Döngüsel karmaşıklık, test kapsamı ölçümüyle doğrudan bağlantılıdır. Bir fonksiyonun karmaşıklık değeri, o fonksiyonu tam olarak test edebilmek için gereken minimum test senaryosu sayısına yakın bir fikir verir. Yani karmaşıklık değeri 5 olan bir fonksiyonu gerçek anlamda kapsamlı test edebilmek için, teorik olarak en az beş farklı yürütme yolunu tetikleyen test senaryolarına ihtiyaç duyulur.

Pratikte çoğu ekip, zaman kısıtları nedeniyle her yolu ayrı ayrı test etmez. Bu durum, yüksek karmaşıklığa sahip ama düşük test kapsamına sahip fonksiyonların ortaya çıkmasına yol açabilir. Böyle fonksiyonlar, içinde test edilmemiş yollar barındırdığı için hata riskini artıran noktalar haline gelebilir. Bu yüzden döngüsel karmaşıklık ve test kapsamı raporları genellikle birlikte incelenir; yüksek karmaşıklığa sahip ama düşük kapsamlı fonksiyonlar, öncelikli olarak ek test yazılması gereken alanlar olarak işaretlenebilir.

Statik Kod Analizi Araçları Bunu Nasıl Hesaplar?

Döngüsel karmaşıklığı elle hesaplamak küçük fonksiyonlar için mümkün olsa da, büyük bir kod tabanında bunu manuel yapmak pratik değildir. Bu noktada statik kod analizi araçları devreye girer.

Bu araçlar, kodu çalıştırmadan (statik olarak) tarar ve her fonksiyon içindeki if, for, while, case gibi yapıları otomatik olarak tespit eder. Ardından, az önce anlattığımız "karar noktaları + 1" mantığını uygulayarak her fonksiyon için bir karmaşıklık değeri üretir.

Sonuçlar genellikle fonksiyon veya dosya bazında raporlanır. Bir rapor, hangi fonksiyonların en yüksek karmaşıklığa sahip olduğunu listeleyebilir ve bunları büyükten küçüğe sıralayabilir. Bazı araçlar, belirlenen bir eşiği aşan fonksiyonları uyarı olarak işaretler; bu uyarılar genellikle kesin bir hata değil, geliştiriciye "burayı gözden geçirmeyi düşün" diyen bir rehber niteliğindedir. Bu sayede geliştirme sürecinde karmaşıklığın zamanla nasıl arttığı da takip edilebilir.

Karmaşıklığı Azaltmak İçin Genel Yaklaşımlar

Yüksek döngüsel karmaşıklığa sahip bir fonksiyonla karşılaşıldığında, izlenebilecek birkaç genel yaklaşım vardır:

• Fonksiyonları küçük parçalara bölmek: Çok fazla karar noktası içeren büyük bir fonksiyon, her biri tek bir sorumluluğu üstlenen daha küçük fonksiyonlara ayrıştırılabilir. Bu, hem her parçanın karmaşıklığını düşürür hem de kodun okunabilirliğini artırır.
• Koşulları sadeleştirmek: İç içe geçmiş çok sayıda if yapısı yerine, erken çıkış (early return) gibi teknikler kullanarak koşulların düz bir yapıya kavuşturulması, hem karmaşıklığı azaltır hem de akışı takip etmeyi kolaylaştırır.
• İç içe yapılardan kaçınmak: Bir döngünün içine başka bir döngü, onun içine de koşullar yerleştirmek yerine, bu mantığı ayrı fonksiyonlara taşımak karmaşıklığı dağıtır.

Bu tür iyileştirmeler, genellikle teknik borç azaltma çabalarının doğal bir parçasıdır. Zamanla büyüyen ve karmaşıklaşan fonksiyonlar, düzenli olarak gözden geçirilip sadeleştirilmezse, gelecekte değiştirilmesi daha maliyetli ve riskli hale gelen bir teknik borç birikimine dönüşebilir.

Tek Başına Yeterli Bir Gösterge Değil

Döngüsel karmaşıklık, kod kalitesi hakkında değerli bir ipucu verse de tek başına yeterli bir gösterge değildir. Bir fonksiyonun karmaşıklık değeri düşük olsa bile, değişken isimlerinin anlamsız olması, kodun okunabilirliğinin düşük olması veya bağımlılık yapısının dağınık olması gibi başka sorunlar taşıyabilir. Benzer şekilde, bazı yüksek karmaşıklık değerleri, kodun doğası gereği (örneğin çok sayıda özel durumun ele alınması gereken bir iş kuralı) kaçınılmaz olabilir.

Bu nedenle tek bir sayıya bakarak kod kalitesi hakkında kesin bir yargıya varmak yanıltıcı olabilir. Kapsamlı bir değerlendirme, döngüsel karmaşıklığın yanı sıra okunabilirlik, bağımlılık yapısı, test kapsamı ve kod kokusu gibi diğer metriklerin bir arada okunmasıyla mümkün olur. Döngüsel karmaşıklık, bu bütünün önemli ama tek başına yeterli olmayan bir parçasıdır.