Python Linters: Temiz Kod için Kapsamlı Bir Rehber

Python projelerinizde kod kalitesini artırmanın, hataları erken yakalamanın ve tutarlı bir stil sağlamanın yollarını mı arıyorsunuz? Python linter’ları ile temiz, okunabilir ve sürdürülebilir kod yazma sanatını keşfedin. Bu rehber, başlangıçtan ileri seviyeye kadar tüm detayları ele alıyor, böylece kod tabanınızı bir sonraki seviyeye taşıyabileceksiniz.

Yazılım geliştirme dünyasında, fonksiyonel bir ürün ortaya koymak kadar, bu ürünün temelini oluşturan kodun kalitesi de hayati bir öneme sahiptir. Peki, bu “kaliteli kod” tam olarak ne anlama geliyor ve neden bu kadar üzerinde duruluyor? Aslında, kaliteli kod; okunabilir, bakımı kolay, anlaşılır, tutarlı ve hata potansiyeli düşük olan kod demektir. Özellikle Python gibi esnek ve dinamik dillerde, aynı işi yapmanın birden fazla yolu olması, kod kalitesi standartlarını daha da önemli hale getirir. Bir proje büyüdükçe, farklı geliştiricilerin katkıları arttıkça veya zamanla özellikler eklendikçe, eğer kod tabanı temiz ve düzenli değilse, bu durum ciddi sorunlara yol açabilir. Örneğin, yeni bir özelliği entegre etmek için saatler harcamanız gerekebilir, çünkü mevcut kodun ne yaptığını anlamak başlı başına bir mücadele haline gelmiştir. Ya da kritik bir hata tespit edildiğinde, bu hatanın kaynağını bulmak adeta bir iğneyi samanlıkta aramak gibi zorlu bir sürece dönüşebilir.

Düşük kaliteli kod, projenin sadece teknik borcunu artırmakla kalmaz, aynı zamanda ekibin verimliliğini de düşürür. Geliştiriciler, yeni kod yazmak yerine mevcut, karmaşık kodu anlamaya ve düzeltmeye daha fazla zaman ayırmak zorunda kalırlar. Bu durum, hem maliyetleri artırır hem de ürünün piyasaya sürülme süresini uzatır. Ayrıca, kod stili tutarsızlıkları da önemli bir sorundur. Bir ekipte her geliştiricinin kendi kod yazma alışkanlıkları varsa, ortaya çıkan kod bir mozaik gibi görünür. Bu durum, kod incelemelerini zorlaştırır, anlaşılabilirliği azaltır ve yeni takım üyelerinin projeye adaptasyonunu geciktirir. PEP 8 gibi standartlar, Python topluluğunda bu tür sorunları önlemek için belirlenmiştir ancak bu standartlara elle uymak yorucu ve hataya açıktır.

İşte tam da bu noktada, Python linter’ları devreye girer. Linter’lar, kodunuzu statik olarak analiz eden ve potansiyel hataları, stil ihlallerini veya şüpheli yapıları otomatik olarak tespit eden araçlardır. Bu araçlar, “kod kalitesi” kavramını somutlaştırmanıza ve geliştirme sürecinizin ayrılmaz bir parçası haline getirmenize yardımcı olur. Erken aşamada hataları yakalamak, kod inceleme süreçlerini kolaylaştırmak ve tüm ekibin aynı stil standartlarına uymasını sağlamak gibi pek çok avantaj sunarlar. Kısacası, linter’lar sadece birer kontrol mekanizması değil, aynı zamanda daha iyi bir yazılımcı olmanıza ve daha sağlam projeler geliştirmenize olanak tanıyan güçlü birer öğrenme aracıdırlar. Bu rehber boyunca, bu araçları nasıl etkili bir şekilde kullanacağınızı detaylıca inceleyeceğiz.

Python Linter Nedir ve Neden Kullanmalıyız? Temel Kavramlar

Bir Python linter’ı, temel olarak, Python kodunuzu çalıştırmadan önce analiz eden bir yazılım aracıdır. Adını, eskiden tekstil endüstrisinde kumaşlardaki fazla iplikleri temizleyen “lint” (tüy/iplik) kelimesinden alır. Yazılım dünyasında da linter’lar, kodunuzdaki “fazla iplikleri”—yani potansiyel sorunları, hataları, stil ihlallerini veya best practice’lere uymayan yapıları—temizlemekle görevlidir. Bu araçlar, derleyicilerin veya yorumlayıcıların genellikle göz ardı ettiği, ancak insan gözüyle fark edilmesi zor olabilen ince detayları ortaya çıkarır.

Linter’lar, statik kod analizi yaparak çalışır. Bu, kodunuzu çalıştırmadan, sadece metin yapısını inceleyerek analiz etmeleri anlamına gelir. Örneğin, kullanılmayan değişkenleri, yanlış girintilemeleri, syntax hatalarını (yorumlayıcının bir hataya düşmeden önce bile), gereksiz import’ları, çok uzun satırları veya PEP 8 gibi stil kılavuzlarına aykırı durumları tespit edebilirler. Bu tespitler, genellikle bir uyarı veya hata mesajı olarak sunulur ve geliştiricinin ilgili kısmı düzeltmesi için bir yol haritası sağlar. Bu süreç, kodunuzun daha temiz, daha okunaklı ve daha sürdürülebilir olmasını sağlar.

Peki, bir Python projesinde neden linter kullanmalıyız? İşte başlıca nedenler:

1. Hata Tespiti ve Önleme: Linter’lar, çalışma zamanında ortaya çıkabilecek birçok hatayı (örneğin, yanlış değişken adları, atlanmış parametreler) daha kod yazım aşamasında yakalayabilir. Bu, geliştirme döngüsünü hızlandırır, hata ayıklama süresini azaltır ve daha güvenilir yazılımlar üretilmesine yardımcı olur. Erken aşamada yakalanan bir hata, prodüksiyonda karşılaşılan bir hatadan çok daha ucuz ve kolay düzeltilir.
2. Kod Kalitesi ve Tutarlılık: Özellikle çok kişilik ekiplerde, her geliştiricinin kendi kodlama stilini uygulaması, projenin genelinde bir tutarsızlık yaratır. Linter’lar, tüm ekibin belirli bir stil kılavuzuna (örneğin PEP 8) uymasını zorunlu kılarak bu sorunu çözer. Bu, kod tabanının genel okunabilirliğini ve bakımı kolaylığını artırır.
3. Öğrenme ve En İyi Uygulamalar: Linter’lar, deneyimli geliştiricilerin kullandığı “best practice”leri ve olası performans tuzaklarını otomatik olarak kontrol eder. Bu sayede, özellikle yeni başlayan geliştiriciler, linter uyarıları sayesinde daha iyi kodlama alışkanlıkları kazanabilir ve yaygın hatalardan kaçınmayı öğrenebilirler. Bu, adeta size sürekli geri bildirim veren bir sanal mentor gibidir.
4. Kod İncelemesi Süreçlerinin Kolaylaştırılması: Kod incelemeleri, bir projenin kalitesini artıran kritik bir adımdır. Ancak stil ve basit hata kontrolleri, bu incelemelerin önemli bir kısmını oluşturur. Linter’lar bu tür kontrolleri otomatikleştirerek, kod inceleyicilerin daha karmaşık mantık ve mimari sorunlara odaklanmasını sağlar. Bu da inceleme sürecini daha verimli ve etkili hale getirir.
5. Sürdürülebilirlik ve Ölçeklenebilirlik: Temiz ve tutarlı kod, projenin uzun vadede sürdürülebilirliğini ve ölçeklenebilirliğini destekler. Yeni özellikler eklemek, mevcut kodu değiştirmek veya hata düzeltmek, iyi linter’lanmış bir kod tabanında çok daha az riskli ve daha hızlıdır.

Özetle, Python linter’ları modern yazılım geliştirmenin ayrılmaz bir parçasıdır. Geliştiricilerin daha az hata yapmasına, daha tutarlı kod yazmasına ve dolayısıyla daha kaliteli ürünler ortaya koymasına yardımcı olan güçlü araçlardır. Onları projenize dahil etmek, başlangıçta küçük bir efor gibi görünse de, uzun vadede size büyük bir zaman ve maliyet tasarrufu sağlayacaktır.

Hangi Python Linter’ını Seçmeliyim? Popüler Araçlara Bakış

Python ekosisteminde birçok etkili linter ve kod biçimlendirme aracı bulunmaktadır. Her birinin kendine özgü güçlü yönleri ve kullanım senaryoları vardır. Doğru aracı seçmek, projenizin ihtiyaçlarına, ekibinizin alışkanlıklarına ve istediğiniz otomasyon seviyesine bağlıdır. İşte en popüler Python linter’ları ve biçimlendiricilerine genel bir bakış:

Flake8: Hızlı ve Kapsamlı Bir Linter

Flake8, Python kodunuzu kontrol etmek için PEP 8 (Python Style Guide) kurallarına ve PyFlakes ile McCabe Complexity metriklerine dayanan popüler bir araçtır. Aslında, Flake8 tek başına bir linter değil, bir “orkestratör”dür. PyFlakes’i (mantıksal hataları kontrol eder), pycodestyle’ı (PEP 8 stilini kontrol eder) ve McCabe’i (kodun karmaşıklığını ölçer) tek bir arayüz altında birleştirir. Bu sayede, aynı anda hem stil ihlallerini hem de potansiyel hataları ve karmaşıklık sorunlarını tespit edebilir. Kurulumu ve kullanımı oldukça basittir, bu da onu birçok geliştirici için başlangıç noktası yapar.

pip install flake8
    

Flake8'in çıktısı genellikle dosya adı, satır numarası, sütun numarası ve hatanın kısa bir kodu ile açıklamasını içerir (örneğin, E501: line too long). Konfigürasyonu kolaydır; belirli kuralları görmezden gelmek veya satır uzunluğu gibi parametreleri değiştirmek için .flake8 dosyası veya pyproject.toml kullanabilirsiniz. Flake8, özellikle mevcut bir kod tabanına stil kontrolü eklemek isteyenler için harika bir seçenektir.

Black: Tartışmasız Kod Biçimlendirici

Black, Python kodu için "tavizsiz" bir biçimlendirici olarak bilinir. Diğer linter'ların aksine, Black kodunuzu biçimlendirme konusunda size çok fazla seçenek sunmaz; bu, kasıtlı bir tasarım kararıdır. Geliştiricilerin kod biçimlendirme tartışmalarına ayırdığı zamanı ortadan kaldırmayı ve tüm projelerde tutarlı bir stil sağlamayı hedefler. Black, PEP 8'e büyük ölçüde uyar ve kodunuzu otomatik olarak yeniden biçimlendirir. Bir kez entegre edildiğinde, kodunuzu kaydettiğinizde veya commit ettiğinizde otomatik olarak çalışacak şekilde ayarlanabilir. Bu, geliştiricilerin stil konusunda düşünmek yerine işlevselliğe odaklanmasını sağlar.

pip install black
    

Black'in felsefesi "Biçimlendirici bir argüman değil, bir araç olmalı"dır. Bu nedenle, çoğu zaman varsayılan ayarlarıyla kullanılır. Projenize ilk kez Black eklediğinizde, tüm kod tabanınızı biçimlendirmek için çalıştırmanız gerekebilir. Bu, genellikle büyük bir "değişiklik" (diff) oluşturur ancak bundan sonraki her değişiklik küçük ve odaklanmış olur.

Pylint: Kapsamlı ve Detaylı Bir Analiz Aracı

Pylint, Python için en eski ve en kapsamlı statik kod analiz araçlarından biridir. Flake8'den daha fazla kontrol ve daha derinlemesine bir analiz sunar. Pylint, sadece stil ihlallerini değil, aynı zamanda kod kalitesi metriklerini, potansiyel hataları (örneğin, yanlış kullanılan argümanlar, gereksiz kodlar), kod kokularını ve anti-pattern'leri de tespit edebilir. Pylint, özellikle büyük ve karmaşık projelerde kodun kalitesini artırmak için çok güçlü bir araçtır. Her dosya için bir "puan" bile verir, böylece zaman içindeki ilerlemeyi takip edebilirsiniz.

pip install pylint
    

Pylint'in kapsamlılığı, bazen çok fazla uyarı üretmesine neden olabilir, bu da başlangıçta bunaltıcı gelebilir. Ancak bu, onu konfigüre edilebilirliği ile dengeler. Pylint'i, projenizin ihtiyaçlarına göre uyarıları açıp kapatarak veya eşikleri ayarlayarak özelleştirebilirsiniz. .pylintrc dosyası, bu özelleştirmeleri yapmanız için kullanılır. Pylint, kodunuzun sadece güzel görünmesini değil, aynı zamanda sağlam ve verimli olmasını da sağlamak isteyen ekipler için idealdir.

Mypy: Statik Tip Denetleyicisi

Mypy, diğer linter'lardan biraz farklıdır çünkü ana odak noktası stil veya genel hatalar değil, Python'daki tip ipuçlarının (type hints) doğru kullanımını denetlemektir. Python dinamik olarak tipli bir dil olsa da, 3.5 sürümünden itibaren tip ipuçları eklenmiştir. Mypy, bu tip ipuçlarını kullanarak kodunuzdaki olası tip uyumsuzluklarını çalışma zamanından önce tespit etmenizi sağlar. Bu, özellikle büyük kod tabanlarında veya karmaşık sistemlerde hata yakalama potansiyelini önemli ölçüde artırır.

pip install mypy
    

Mypy, Python'un esnekliğini korurken statik tipli dillerin faydalarını sağlamanıza yardımcı olur. Bir fonksiyonun beklediği tipte bir argüman alıp almadığını veya bir değişkenin beklenmedik bir tip atamasına sahip olup olmadığını kontrol edebilir. Tip ipuçları kullanımı, kodun okunabilirliğini ve anlaşılabilirliğini de artırır, böylece Mypy dolaylı olarak kod kalitesine katkıda bulunur.

Her bir aracın kendi avantajları ve dezavantajları vardır. Çoğu zaman, bir geliştirme ekibi bu araçların bir kombinasyonunu kullanır: örneğin, Black otomatik biçimlendirme için, Flake8 stil ve basit hata kontrolleri için ve Mypy tip kontrolü için. Önemli olan, ekibinizin iş akışına en uygun olanı bulmak ve bu araçları düzenli olarak kullanmayı bir alışkanlık haline getirmektir.

Flake8 ile İlk Adımlar: Projelerinize Nasıl Entegre Edilir?

Flake8, Python geliştiricileri arasında popülerliğini basitliği, hızı ve etkili hata tespiti yeteneği sayesinde kazanmıştır. Projenize entegre etmek oldukça kolaydır ve mevcut bir kod tabanına hızla değer katabilir. İşte Flake8 ile ilk adımlarınızı atmanız için adım adım bir rehber:

1. Flake8 Kurulumu

Flake8'i projenize eklemenin ilk adımı, onu projenizin sanal ortamına kurmaktır. Genellikle pip kullanarak bu işlemi gerçekleştirebilirsiniz:

pip install flake8
    

Kurulum tamamlandıktan sonra, terminalinizden flake8 --version komutunu çalıştırarak kurulumun başarılı olup olmadığını kontrol edebilirsiniz. Bu komut, yüklü Flake8 sürümünü ve kullandığı eklentileri gösterecektir.

2. Flake8'i Projenizde Çalıştırma

Flake8'i kurduktan sonra, onu herhangi bir Python dosyası veya dizin üzerinde çalıştırabilirsiniz. En temel kullanım, projenizin kök dizininde aşağıdaki komutu çalıştırmaktır:

flake8 .
    

Bu komut, geçerli dizindeki tüm Python dosyalarını (alt dizinler dahil) kontrol eder. Çıktı, her bir ihlal için dosya adı, satır numarası, sütun numarası, hata kodu ve açıklamasını içeren bir liste olacaktır. Örneğin:

my_module/utils.py:10:80: E501 line too long (82 > 79 characters)
my_module/main.py:5:1: F401 'os' imported but unused
    

E501, satır uzunluğu ihlallerini, F401 ise kullanılmayan import'ları belirtir. Bu kodlar, Flake8'in denetlediği farklı kural setlerinden gelir (PyFlakes'ten 'F' kodları, pycodestyle'dan 'E' ve 'W' kodları).

3. Flake8'i Yapılandırma (Konfigürasyon)

Flake8'in varsayılan kuralları çoğu proje için iyi bir başlangıç noktası olsa da, belirli projenizin ihtiyaçlarına göre uyarlamanız gerekebilir. Konfigürasyon, .flake8 dosyası veya pyproject.toml dosyası aracılığıyla yapılabilir. .flake8 dosyası, genellikle projenin kök dizinine yerleştirilir ve INI formatında yazılır.

Örnek bir .flake8 dosyası:

[flake8]
max-line-length = 100
exclude = .git,__pycache__,docs,venv,migrations
ignore = E501,W503
    

• max-line-length = 100: Varsayılan 79 karakter yerine satır uzunluğunu 100 karakterle sınırlar.
• exclude: Flake8'in kontrol etmeyeceği dizinleri veya dosyaları belirtir. Bu, genellikle venv (sanal ortamlar), docs (belgeleme) ve migrations (veritabanı göçleri) gibi otomatik olarak oluşturulan veya üçüncü parti kodları dışlamak için kullanılır.
• ignore: Belirli hata kodlarını görmezden gelmeyi sağlar. Yukarıdaki örnekte, E501 (satır uzunluğu) ve W503 (binary operatörden önce boşluk) ihlalleri tamamen yok sayılır. Bu, projenizin belirli bir stil kararı aldığında veya bir kuralın mevcut kod tabanınızla uyumlu olmadığını düşündüğünüzde kullanışlıdır.

Eğer projenizde pyproject.toml kullanıyorsanız, Flake8 konfigürasyonunu bu dosyanın içine, [tool.flake8] başlığı altında da ekleyebilirsiniz:

[tool.flake8]
max-line-length = 100
exclude = [".git", "__pycache__", "docs", "venv", "migrations"]
ignore = ["E501", "W503"]
    

4. Belirli Satırları ve Dosyaları Görmezden Gelme

Bazı durumlarda, bir kuralı genel olarak ignore etmek yerine, belirli bir satırda veya dosyada sadece bir defaya mahsus olmak üzere görmezden gelmek isteyebilirsiniz. Flake8 bunu, özel yorumlar aracılığıyla destekler:

• Tek bir satırı görmezden gelmek için:

  
  very_long_variable_name = "This is a very long string that will exceed the maximum line length."  # noqa: E501
              

  # noqa: E501 yorumu, Flake8'e bu satırdaki E501 hatasını yok saymasını söyler.

• Bir dosyadaki tüm ihlalleri görmezden gelmek için: Dosyanın en üstüne # flake8: noqa ekleyebilirsiniz. Ancak bu genellikle önerilmez, çünkü dosyanın tamamındaki tüm kontrolleri devre dışı bırakır. Daha iyi bir yaklaşım, dosyanın başlığında belirli hataları belirtmektir:

  
  # flake8: noqa: F401,E123
  import os # F401 hatası burada yok sayılır
  
  def my_function():
      pass
  # E123 hatası bu dosyada yok sayılır
              

Vaka Analizi: Yeni Bir Ekipte Flake8 Entegrasyonu

Küçük bir yazılım girişimi, hızlı bir şekilde büyümeye başlamış ve yeni geliştiricileri işe almıştı. Kod tabanı büyüdükçe, farklı geliştiricilerin kod stilleri nedeniyle kod incelemeleri uzamaya ve tartışmalar artmaya başlamıştı. Ayrıca, bazen basit mantıksal hatalar veya kullanılmayan değişkenler prodüksiyona kadar sızabiliyordu. Ekip lideri, bu sorunları çözmek için Flake8'i projeye entegre etmeye karar verdi.

İlk adımda, Flake8 kuruldu ve mevcut kod tabanında çalıştırıldı. Beklendiği gibi, yüzlerce uyarı ve hata tespit edildi. Ancak, tüm hataları aynı anda düzeltmek yerine, ekip kademeli bir yaklaşım benimsedi. Öncelikle, en yaygın ihlaller (E501 - satır uzunluğu ve F401 - kullanılmayan import'lar) için .flake8 dosyasına istisnalar eklendi. Daha sonra, her yeni kod değişikliğinde (pull request) Flake8 kontrolleri zorunlu hale getirildi. Bu sayede, eski kod tabanına dokunmadan, yeni yazılan tüm kodların Flake8 standartlarına uygun olması sağlandı. Zamanla, teknik borç azaldıkça ve geliştiriciler Flake8'in geri bildirimlerine alıştıkça, istisna edilen kurallardan bazıları yavaş yavaş tekrar aktif edildi.

Bu kademeli entegrasyon sayesinde, ekip kısa sürede kod stilinde büyük bir tutarlılık yakaladı, kod incelemeleri daha verimli hale geldi ve hata oranı azaldı. Flake8, yeni geliştiricilerin Python'un en iyi uygulamalarını hızlı bir şekilde öğrenmelerine de yardımcı oldu.

Flake8, Python geliştirme sürecinizin vazgeçilmez bir parçası olabilir. Doğru konfigürasyon ve düzenli kullanım ile kod kalitenizi önemli ölçüde artırabilir ve geliştirme ekibinizin daha verimli çalışmasını sağlayabilir.

Black ile Otomatik Kod Biçimlendirme: Tartışmalara Son!

Geliştirme ekipleri arasında kod stili üzerine yapılan tartışmalar, genellikle zaman kaybına ve gereksiz enerji harcamalarına neden olur. "Sekmeler mi boşluklar mı?", "Tek tırnak mı çift tırnak mı?", "Satır sonu virgül olmalı mı?" gibi sorular, asıl işlevsel sorunlardan dikkati dağıtabilir. İşte Black, tam da bu noktada devreye giriyor ve bu tür tartışmalara kökten bir çözüm sunuyor: otomatik, tavizsiz ve tutarlı kod biçimlendirme. Black'in temel amacı, kodunuzu PEP 8 standardına mümkün olduğunca yakın bir şekilde biçimlendirirken, geliştiricilerin biçimlendirme konusunda düşünmelerini tamamen ortadan kaldırmaktır.

1. Black Kurulumu

Black'i projenize eklemek, diğer linter'lar gibi pip aracılığıyla yapılır:

pip install black
    

Kurulumdan sonra, terminalinizde black --version komutunu çalıştırarak başarılı bir kurulumu teyit edebilirsiniz.

2. Black'i Projenizde Çalıştırma

Black'i kullanmak oldukça basittir. Projenizin kök dizininde aşağıdaki komutu çalıştırarak tüm Python dosyalarını biçimlendirebilirsiniz:

black .
    

Bu komut, geçerli dizindeki ve alt dizinlerindeki tüm .py dosyalarını tarar ve Black'in standartlarına göre yeniden biçimlendirir. Black, sadece "değişiklikleri" (diff) gösteren bir önizleme yapmak istiyorsanız --check ve --diff bayraklarını kullanmanızı öneririz:

black --check --diff .
    

Bu komut, Black'in hangi değişiklikleri yapacağını görsel olarak gösterir ancak dosyaları gerçekten değiştirmez. Bu, özellikle Black'i ilk kez büyük bir kod tabanına uygularken çok kullanışlıdır, çünkü değişiklikleri gözden geçirme ve onaylama şansı verir.

3. Black'i Yapılandırma

Black, "tavizsiz" olduğu için çok fazla konfigürasyon seçeneği sunmaz. Ancak yine de bazı temel ayarları pyproject.toml dosyası aracılığıyla yapabilirsiniz. pyproject.toml dosyasının [tool.black] bölümü altında aşağıdaki gibi ayarlar yapabilirsiniz:

[tool.black]
line-length = 88
target-version = ['py37', 'py38', 'py39', 'py310']
include = '\.pyi?$'
exclude = '''
/(
    \.git
  | \.hg
  | \.mypy_cache
  | \.tox
  | \.venv
  | _build
  | buck-out
  | build
  | dist
)/
'''
    

• line-length = 88: Black'in varsayılan satır uzunluğu 88 karakterdir. Flake8'in 79 veya 100 karakterlik standartlarından farklı bir değer kullanır. Bu değeri değiştirebilirsiniz ancak Black'in kendi tercih ettiği bir değer olduğunu unutmayın.
• target-version: Hedeflenen Python sürümlerini belirtir. Black, bu sürümlerin özel syntax özelliklerini doğru bir şekilde biçimlendirebilmek için bu bilgiye ihtiyaç duyar.
• include ve exclude: Black'in hangi dosyaları dahil edeceğini veya hariç tutacağını belirten düzenli ifadelerdir (regular expressions). Bu, özellikle belirli dizinleri (örneğin venv, build) veya dosya türlerini (örneğin sadece .py dosyaları) işlemek için kullanışlıdır.

4. IDE Entegrasyonu

Black'in gücü, geliştirme sürecinize sorunsuz bir şekilde entegre edildiğinde ortaya çıkar. Çoğu modern IDE (PyCharm, VS Code vb.) Black ile entegrasyonu destekler. Örneğin, VS Code'da Python eklentisini kurduktan sonra, ayarlarınızda "Format On Save" (kaydedince biçimlendir) özelliğini açabilir ve biçimlendirici olarak Black'i seçebilirsiniz. Bu sayede, her dosyayı kaydettiğinizde kodunuz otomatik olarak biçimlendirilir ve siz stil endişeleriyle uğraşmazsınız.

// settings.json (VS Code)
{
    "python.formatting.provider": "black",
    "editor.formatOnSave": true
}
    

Vaka Analizi: Büyük Bir Açık Kaynak Projesinde Black Kullanımı

Popüler bir açık kaynak Python kütüphanesi, yüzlerce katkıda bulunan geliştiricisi ve yıllarca süren bir kod tabanına sahipti. Proje, çeşitli kod stillerini barındırıyordu ve bu durum, yeni katkıda bulunanların projeye dahil olmasını zorlaştırıyor, mevcut geliştiricilerin kod incelemelerinde stil tartışmalarına takılı kalmasına neden oluyordu. Çekirdek ekip, bu soruna bir son vermek için Black'i entegre etmeye karar verdi.

Black'in entegrasyonu iki aşamalı olarak yapıldı: İlk olarak, tek bir büyük commit ile tüm kod tabanı Black tarafından biçimlendirildi. Bu commit, proje geçmişinde kolayca izlenebilmesi için açıkça etiketlendi. İkinci olarak, CI/CD pipeline'ına bir Black kontrol adımı eklendi. Her pull request oluşturulduğunda, Black'in --check bayrağı ile çalıştırılması zorunlu hale getirildi. Eğer bir kod parçası Black tarafından biçimlendirilmemişse, CI testi başarısız oluyordu ve geliştiricinin kodu tekrar biçimlendirmesi gerekiyordu.

Bu entegrasyon, başlangıçta bazı küçük dirençlerle karşılaşsa da, kısa sürede büyük faydalar sağladı. Kod incelemeleri artık stil tartışmalarından arındırılmıştı, yeni katkıda bulunanlar için kod tabanına adaptasyon süresi kısaldı ve projenin genelindeki kod tutarlılığı zirveye çıktı. Black, kütüphanenin sürdürülebilirliğini ve daha fazla katkıya açık olmasını sağlayan kilit bir araç haline geldi.

Black, Python kodunuzdaki biçimlendirme sorunlarını otomatikleştirerek ekibinizin daha verimli çalışmasına ve gerçekten önemli konulara odaklanmasına olanak tanır. Python geliştirme sürecinizin ayrılmaz bir parçası olarak, kod kalitesini artırmak ve ekip içi uyumu sağlamak için güçlü bir müttefiktir.

Linter'ları Geliştirme Sürecinize Nasıl Dahil Edersiniz? CI/CD ve Pre-commit Kancaları

Linter'ları projenize kurmak ve manuel olarak çalıştırmak iyi bir başlangıçtır, ancak gerçek gücü, onları geliştirme iş akışınızın ayrılmaz bir parçası haline getirdiğinizde ortaya çıkar. Bu, genellikle iki ana yolla sağlanır: pre-commit kancaları (hooks) ve Sürekli Entegrasyon/Sürekli Dağıtım (CI/CD) pipeline'ları. Bu yöntemler, kod kalitesini erken aşamada güvence altına alarak, daha sonraki aşamalarda karşılaşılabilecek sorunları ve maliyetleri önemli ölçüde azaltır.

1. Pre-commit Kancaları ile Yerel Kontrol

Pre-commit kancaları, adından da anlaşılacağı gibi, bir Git commit'i yapmadan hemen önce çalışan betiklerdir. Bu kancalar, kodunuzun commit edilmeden önce belirli kalite kontrollerinden geçmesini zorunlu kılarak, kirli veya hatalı kodun sürüm kontrol sistemine girmesini engeller. Bu, özellikle her geliştiricinin kendi makinesinde tutarlılık sağlamak için harika bir yöntemdir.

pre-commit Çerçevesi ile Kurulum

Python projelerinde pre-commit kancalarını yönetmek için en popüler ve etkili araç pre-commit çerçevesidir. Bu araç, çeşitli linter'ları ve biçimlendiricileri kolayca entegre etmenizi sağlar.

Adım 1: pre-commit Kurulumu

pip install pre-commit
    

Adım 2: Konfigürasyon Dosyası Oluşturma

Projenizin kök dizinine .pre-commit-config.yaml adında bir dosya oluşturun ve içine kullanmak istediğiniz araçları tanımlayın. Örneğin, Black ve Flake8'i dahil edelim:

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0 # En son sürümü kullanın
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files
  - repo: https://github.com/psf/black
    rev: 23.3.0 # En son sürümü kullanın
    hooks:
      - id: black
  - repo: https://github.com/pycqa/flake8
    rev: 6.0.0 # En son sürümü kullanın
    hooks:
      - id: flake8
    

• repos: Farklı araçların (linterlar, formatlayıcılar, yardımcı betikler) bulunduğu Git depolarını listeler.
• rev: Kullanılacak deponun sürümünü (etiketini) belirtir. Güvenilirlik için belirli bir sürüm kullanmak önemlidir.
• hooks: Belirtilen depodaki hangi kancaların (id ile tanımlanır) kullanılacağını listeler.

Adım 3: Kancaları Yükleme

Konfigürasyon dosyasını oluşturduktan sonra, projenizin .git dizinine kancaları yüklemek için aşağıdaki komutu çalıştırın:

pre-commit install
    

Artık her git commit komutunu çalıştırdığınızda, pre-commit çerçevesinde tanımladığınız araçlar otomatik olarak çalışacaktır. Eğer Black kodu biçimlendirirse veya Flake8 bir hata bulup düzeltemezse, commit işlemi durdurulur ve size geri bildirim sağlanır. Black otomatik düzeltmeler yaparsa, değişiklikleri tekrar eklemeniz (git add .) ve commit'i tekrar denemeniz gerekebilir.

2. CI/CD Pipeline'ları ile Sunucu Taraflı Kontrol

Pre-commit kancaları yerel makinede harika çalışır, ancak yine de atlanabilirler. Bu nedenle, kod kalitesi kontrollerini merkezi bir CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) pipeline'ına entegre etmek en iyi uygulamadır. CI/CD, her kod değişikliğinde (genellikle bir pull request veya push ile) otomatik olarak testleri çalıştıran, linter kontrollerini yapan ve kodu dağıtıma hazırlayan bir süreçtir. Bu, tüm ekibin kod kalitesi standartlarına uymasını zorunlu kılar ve hatalı kodun ana branch'e (örn. main) birleşmesini engeller.

Örnek CI/CD Entegrasyonu (GitHub Actions)

Çoğu CI/CD platformu benzer mantıkla çalışır. İşte GitHub Actions kullanarak Black ve Flake8'i bir pipeline'a entegre etmenin basit bir örneği:

Projenizin kök dizininde .github/workflows/main.yml adında bir dosya oluşturun:

# .github/workflows/main.yml
name: Code Quality Checks

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3 # Depoyu çek

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.x'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install flake8 black pre-commit

    - name: Run pre-commit hooks (for Flake8 and Black --check)
      run: pre-commit run --all-files
      # Bu komut, pre-commit config dosyanızdaki tüm hook'ları çalıştırır.
      # Black'in otomatik düzeltmeleri varsa, bu adımda hata verecektir.
      # Bu, PR'ı gönderen geliştiricinin kodu yerel olarak formatlamasını sağlar.

    - name: Check code formatting with Black
      run: black --check .
      # Alternatif olarak Black'i doğrudan çalıştırabilirsiniz.
      # --check bayrağı, formatlama yapmadan sadece kontrol eder.
      # Eğer Black değişiklik yapması gerektiğini tespit ederse, bu adım başarısız olur.

    - name: Lint code with Flake8
      run: |
        flake8 . --max-line-length=100 --ignore=E501,W503
      # Flake8'i doğrudan çalıştırarak belirli kuralları görmezden gelebilirsiniz.
      # Bu, .flake8 config dosyanızdaki ayarlara da uyacaktır.
    

• on: [push, pull_request]: Bu iş akışının hem push hem de pull_request olaylarında tetikleneceğini belirtir.
• jobs.lint.steps:
  • Depoyu çeker, Python ortamını kurar ve gerekli bağımlılıkları yükler (flake8, black, pre-commit).
  • pre-commit run --all-files komutu, tüm pre-commit kancalarını (Black ve Flake8 dahil) çalıştırır. Eğer Black bir formatlama yapması gerektiğini bulursa veya Flake8 bir hata bulursa bu adım başarısız olur.
  • Ekstra güvenlik için Black ve Flake8'i doğrudan --check bayraklarıyla da çalıştırabilirsiniz. Bu, geliştiricilerin yerel olarak kancaları atlama ihtimaline karşı bir sigorta görevi görür.

Vaka Analizi: Büyük Bir Kurumsal Uygulama İçin Gelişmiş CI/CD Entegrasyonu

Finans sektöründe faaliyet gösteren büyük bir şirket, kritik bir Python uygulamasının geliştirilmesi sırasında kod kalitesini en üst düzeyde tutmayı hedefliyordu. Uygulama, birçok farklı ekip tarafından geliştirilen yüzlerce modülden oluşuyordu. Yerel pre-commit kancaları kullanılıyordu, ancak bazen geliştiriciler bu kancaları atlayabiliyordu ve ana branch'e stil hataları veya potansiyel güvenlik açıkları sızıyordu. Bu durumu önlemek için, GitLab CI/CD pipeline'larına kapsamlı bir linter ve statik analiz entegrasyonu yapıldı.

Pipeline'da birden fazla aşama tanımlandı:

1. lint_format Aşaması: Bu aşamada, önce Black --check bayrağı ile çalıştırıldı. Ardından, Flake8 ve Pylint çalıştırıldı. Herhangi bir aracın hata vermesi durumunda pipeline başarısız oluyordu. Bu sayede, temel stil ve potansiyel hata kontrolleri zorunlu hale getirildi.
2. type_check Aşaması: Mypy, tüm modüllerdeki tip ipuçlarının doğruluğunu kontrol etmek için çalıştırıldı. Bu, özellikle veri akışının kritik olduğu finansal uygulamalarda büyük önem taşıyordu.
3. security_scan Aşaması: Bandit gibi güvenlik linter'ları, yaygın güvenlik açıklarını (örneğin, hardcoded şifreler, SQL injection riskleri) otomatik olarak taradı.
4. code_complexity Aşaması: Radon gibi araçlar, kodun karmaşıklığını (Cyclomatic Complexity) ölçmek için kullanıldı ve belirlenen eşiklerin üzerindeki fonksiyonlar için uyarılar verildi.

Bu çok aşamalı entegrasyon sayesinde, şirketin kod kalitesi ve güvenliği önemli ölçüde arttı. Her pull request, ana branch'e birleşmeden önce bu kapsamlı kontrollerden geçmek zorundaydı. Bu yaklaşım, sadece hataları erken yakalamakla kalmadı, aynı zamanda geliştiricilerin "temiz kod" ve "güvenli kod" yazma bilincini de geliştirdi. Ek olarak, pipeline raporları sayesinde, yöneticiler kod kalitesi metriklerini zaman içinde takip edebildiler ve teknik borç seviyesini daha iyi yönetebildiler.

Linter'ları pre-commit kancaları ve CI/CD pipeline'ları aracılığıyla entegre etmek, geliştirme sürecinizi otomatikleştirmenin ve kod kalitesini sürekli olarak güvence altına almanın en etkili yoludur. Bu sayede, ekibiniz daha verimli çalışabilir ve daha güvenilir yazılımlar ortaya koyabilir.

İleri Düzey Linter Kullanımı ve Özel Konfigürasyonlar: Daha Derinlemesine Bakış

Python linter'ları, sadece basit stil kontrollerinin ötesine geçerek, deneyimli geliştiriciler için daha gelişmiş konfigürasyon ve kullanım senaryoları sunar. Kod tabanınız büyüdükçe veya belirli projeleriniz için özel ihtiyaçlar ortaya çıktıkça, linter'larınızı daha ince ayarlarla özelleştirmeniz gerekebilir. Bu bölümde, linter'larınızı daha etkili kullanmanızı sağlayacak ileri düzey tekniklere ve özel konfigürasyonlara değineceğiz.

1. Kendi Linter Kurallarınızı Tanımlama ve Eklentiler

Bazı linter'lar, mevcut kuralların ötesine geçerek kendi özel denetimlerinizi tanımlamanıza olanak tanır. Örneğin, Flake8 için eklentiler yazabilir veya belirli şirket standartlarına uygun özel kontroller geliştirebilirsiniz. Bu, özellikle büyük kuruluşlarda veya belirli bir domain bilgisi gerektiren projelerde çok kullanışlıdır. Bir örnek olarak, şirketinizin veritabanı etkileşimlerinde belirli bir ORM kullanımını zorunlu kılan veya özel bir güvenlik denetimi yapan bir kural yazabilirsiniz.

Flake8, eklenti tabanlı bir mimariye sahiptir. Kendi eklentinizi yazarak (Python'da bir modül olarak) özel denetimler ekleyebilirsiniz. Bu, genellikle AST (Abstract Syntax Tree) traversalı veya token tabanlı analizleri içerir. Bu sayede, örneğin, belirli bir fonksiyon adının kullanılmasını yasaklayabilir veya özel bir yorum formatını zorunlu kılabilirsiniz.

2. Linter Performansını Optimize Etme

Büyük kod tabanlarında, linter'ları çalıştırmak zaman alabilir. CI/CD pipeline'larında veya pre-commit kancalarında bu durum, geliştirme döngüsünü yavaşlatabilir. Linter performansını optimize etmek için bazı stratejiler:

• Hedefli Çalıştırma: Her zaman tüm kod tabanını taramak yerine, yalnızca değişen dosyaları tarayacak şekilde linter'ları konfigüre edin. pre-commit çerçevesi bunu otomatik olarak yapar. CI/CD'de de, sadece son commit'te değişen dosyaları hedeflemek için özel betikler yazılabilir.
• Paralel Çalıştırma: Birden fazla linter kullanıyorsanız (örneğin Flake8, Black, Mypy), bunları paralel olarak çalıştırmayı düşünün. Çoğu CI/CD platformu (örneğin GitHub Actions'daki ayrı işler) bunu destekler.
• Önbellekleme (Caching): Bazı linter'lar (veya pre-commit gibi araçlar), önceki çalıştırmaların sonuçlarını önbelleğe alabilir. CI/CD pipeline'larında bu önbellekleri kullanmak, tekrar eden çalıştırmaların süresini önemli ölçüde azaltır.
• Gereksiz Dosyaları Dışlama: venv, build dizinleri, otomatik oluşturulan kodlar veya üçüncü parti kütüphanelerin kaynak kodları gibi linter'lanmaması gereken dizinleri ve dosyaları exclude listelerinize eklediğinizden emin olun.

3. Eski Kod Tabakalarıyla Başa Çıkma (Legacy Code)

Mevcut, büyük ve eski bir kod tabanına linter'ları entegre etmek zorlu olabilir. Genellikle, binlerce uyarı ve hata ile karşılaşırsınız. Bu durumda, pratik bir yaklaşım benimsemek önemlidir:

• Aşamalı Entegrasyon: Tüm hataları bir kerede düzeltmeye çalışmak yerine, öncelikle en kritik veya en yaygın hatalara odaklanın. İlk başta, birçok kuralı görmezden gelmek ve zamanla kod tabanını temizledikçe bu kuralları yavaş yavaş tekrar aktif etmek daha sürdürülebilir bir stratejidir.
• Baseline Oluşturma: Bazı linter'lar (örneğin Pylint), mevcut hataların bir "baseline"ını oluşturmanıza ve yalnızca bu baselinenin üzerindeki yeni hataları raporlamanıza olanak tanır. Bu, yeni yazılan kodun temiz olmasını sağlarken, eski kodun bir anda düzeltilmesi baskısını ortadan kaldırır.
• Düzeltme Kampanyaları: Periyodik olarak, belirli bir linter hatasını veya bir bölümdeki tüm linter hatalarını düzeltmek için "temizleme kampanyaları" düzenleyin. Bu, teknik borcu yönetilebilir parçalara ayırmanıza yardımcı olur.

# Örnek: Flake8 için mevcut hataları ignore etmek
# .flake8 dosyasında veya pyproject.toml'da
# ignore = E302,E265,W292  # Başlangıçta görmezden gelinecek yaygın hatalar

# Zamanla, kod kalitesi iyileştikçe bu listeyi daraltın.
    

4. Özelleştirilmiş Raporlama ve Görselleştirme

Linter'ların çıktısı genellikle terminal tabanlıdır, ancak bu çıktıları daha görsel ve anlaşılır hale getirmek için araçlar kullanabilirsiniz. Örneğin:

• Sarif Formatı: Bazı linter'lar (veya entegrasyon araçları), statik analiz sonuçlarını SARIF (Static Analysis Results Interchange Format) adı verilen standart bir formata dışa aktarabilir. Bu format, GitHub gibi platformlarda kod güvenlik taraması sonuçlarını görselleştirmek için kullanılır.
• Özel Raporlama Araçları: Linter çıktısını JSON veya XML gibi formatlara dönüştüren araçlar kullanarak, kendi özel raporlama ve metrik dashboard'larınızı oluşturabilirsiniz. Bu, zaman içindeki kod kalitesi trendlerini izlemek için çok değerli olabilir.

Bu ileri düzey kullanım teknikleri, linter'larınızı basit bir kontrol aracından, projenizin yazılım kalitesini sürekli olarak artıran güçlü bir mühendislik aracına dönüştürmenize yardımcı olur. Projenizin büyüklüğü, ekibinizin deneyimi ve kalite hedefleriniz doğrultusunda bu yöntemleri keşfetmek, daha sağlam ve sürdürülebilir yazılımlar geliştirmenizi sağlayacaktır.

Sonuç: Temiz Kod Kültürü ve Gelecek

Python linter'ları ve otomatik kod biçimlendiriciler, modern yazılım geliştirme sürecinin vazgeçilmez araçları haline gelmiştir. Bu rehber boyunca ele aldığımız gibi, bu araçlar sadece basit stil ihlallerini tespit etmekle kalmıyor, aynı zamanda potansiyel hataları erken aşamada yakalayarak, kod tabanının okunabilirliğini, bakımını ve genel sürdürülebilirliğini artırıyor. Flake8'in kapsamlı stil ve hata denetimleri, Black'in tavizsiz otomatik biçimlendirmesi, Pylint'in derinlemesine analizi ve Mypy'nin statik tip kontrolü gibi araçlar, her Python geliştiricisinin araç setinde olması gereken güçlü müttefiklerdir.

Bu araçları, pre-commit kancaları ve CI/CD pipeline'ları aracılığıyla geliştirme iş akışınıza entegre etmek, kod kalitesi standartlarını projenin her aşamasında güvence altına almanın en etkili yoludur. Bu entegrasyon, kirli kodun sürüm kontrol sistemine girmesini engeller, kod inceleme süreçlerini hızlandırır ve tüm ekibin aynı kalite beklentisine sahip olmasını sağlar. Dahası, linter'lar sadece birer denetim mekanizması değil, aynı zamanda geliştiricilerin "en iyi uygulamaları" öğrenmeleri ve kodlama becerilerini sürekli olarak geliştirmeleri için güçlü birer geri bildirim aracıdır.

Temiz kod, sadece estetik bir tercih değil, aynı zamanda projenizin uzun vadeli başarısı için kritik bir yatırım anlamına gelir. Daha az hata, daha hızlı geliştirme, daha kolay bakım ve daha mutlu bir geliştirme ekibi demektir. Python linter'ları, bu temiz kod kültürünü oluşturmanız ve sürdürmeniz için size somut ve otomatikleştirilmiş bir yol sunar. Gelecekte, yapay zeka destekli kod analizi araçlarının daha da gelişeceği ve linter'ların daha akıllı ve öngörülü hale geleceği bir dünyada, bu araçları etkin bir şekilde kullanma becerisi, her zaman değerli bir yetkinlik olarak kalacaktır.

Şimdi, bu bilgileri kendi projelerinize uygulamak ve Python kodunuzu bir sonraki seviyeye taşımak sizin elinizde. Unutmayın, iyi kod yazmak sadece bir beceri değil, aynı zamanda bir alışkanlıktır ve linter'lar bu alışkanlığı kazanmanızda en büyük yardımcılarınızdan biridir.

Sıkça Sorulan Sorular (SSS)

1. Bir projede birden fazla linter kullanmak mümkün müdür?

Evet, kesinlikle mümkündür ve çoğu zaman tavsiye edilir. Örneğin, kod biçimlendirme için Black'i, stil ve basit hata tespiti için Flake8'i ve tip kontrolü için Mypy'yi birlikte kullanabilirsiniz. pre-commit çerçevesi veya CI/CD pipeline'ları, bu farklı araçları aynı iş akışı içinde sorunsuz bir şekilde birleştirmenize olanak tanır.

2. Linter'lar güvenlik açıklarını tespit edebilir mi?

Bazı linter'lar (örneğin Pylint, veya Bandit gibi özel güvenlik linter'ları) yaygın güvenlik açıklarını (SQL injection riskleri, hardcoded şifreler vb.) tespit edebilir. Ancak linter'lar, kapsamlı bir güvenlik denetiminin yalnızca bir parçasıdır ve tek başına yeterli değildir. Daha derinlemesine güvenlik analizi için özel güvenlik araçları ve manuel denetimler de gereklidir.

3. Linter hatalarını tamamen yok saymak iyi bir uygulama mıdır?

Genellikle, bir linter hatasını tamamen yok saymak (# noqa veya konfigürasyon dosyalarında ignore ile) en son çare olmalıdır. Her hatanın bir nedeni vardır ve düzeltilmesi, kod kalitesini artırır. Ancak, nadiren de olsa, belirli bir kuralın projenizin veya belirli bir kod parçasının özel gereksinimlerine uymadığı durumlar olabilir. Bu gibi durumlarda, hatayı açıkça belgeleyerek ve neden yok sayıldığını açıklayarak ignore etmek daha iyi bir yaklaşımdır.

4. Linter'lar otomatik olarak kodumu düzeltebilir mi?

Evet, bazı linter'lar ve özellikle kod biçimlendiriciler (örneğin Black, autopep8) kodunuzdaki belirli sorunları otomatik olarak düzeltebilir. Black, kod biçimlendirme standartlarını uygularken otomatik olarak kodu değiştirir. Flake8 gibi linter'lar ise genellikle sadece raporlama yapar, ancak bazı hataları otomatik olarak düzeltebilen eklentileri veya yardımcı araçları mevcuttur. Otomatik düzeltme yeteneği, geliştirme sürecini hızlandırır ancak yapılan değişiklikleri her zaman gözden geçirmek önemlidir.

Bu makalede sunulan HTML yapısı, modern tarayıcılarda varsayılan olarak mobil cihazlarda da iyi görüntülenmek üzere tasarlanmıştır. Ancak, daha gelişmiş bir mobil uyumluluk ve kullanıcı deneyimi için, CSS içerisinde @media sorgularının kullanılması kritik öneme sahiptir. Örneğin, bir tabloyu küçük ekranlarda daha okunabilir hale getirmek veya çok sütunlu bir düzeni tek sütuna indirmek için bu sorgulardan faydalanılır:

/* Örnek CSS: Küçük ekranlar için tablo uyarlaması */
@media screen and (max-width: 768px) {
    table {
        display: block;
        overflow-x: auto; /* Yatay kaydırma çubuğu ekler */
        white-space: nowrap;
    }

    /* Tablo hücrelerinin küçük ekranlarda nasıl görünmesi gerektiği */
    th, td {
        min-width: 120px; /* Hücre genişliğini ayarla */
    }

    /* Belirli elementleri gizle veya boyutlandır */
    .expert-tip {
        margin: 10px 0;
        padding: 10px;
        font-size: 0.9em;
    }
}
    

Bu tür kurallar, metin boyutlarının ayarlanması, resimlerin ve diğer medya öğelerinin esnek hale getirilmesi (max-width: 100%; height: auto; gibi), navigasyon menülerinin responsive hale getirilmesi ve genel sayfa düzeninin küçük ekranlara adapte edilmesi için kullanılır. HTML içeriğinin semantik ve erişilebilir olması da mobil uyumluluğun temelini oluşturur.