hkucuk

Yazılımcıların Bilmesi Gereken Prensipler

23 Ocak 2023 • ☕️ 6 dk okuma • 🏷 bilgisayar, yazılım

Yazar tarafından şu dillere çevrildi: Deutsch • English


Yazılım geliştirme dünyası hızla ilerliyor ve bu hızlı ilerleyiş, geliştiricilerin daha fazla sayıda proje üzerinde çalışmasını gerektiriyor. Ancak, yazılım geliştirirken, belirli prensiplere uymak, kodun daha okunaklı, yeniden kullanılabilir ve bakımı yapılabilir olmasını sağlamak açısından son derece önemlidir.

Bu nedenle, yazılım geliştirme sürecinde sık kullanılan bazı prensipler mevcuttur. Bu makalede YAGNI, DRY, SOC, KISS, LOD ve SOLID prensiplerini inceleyeceğiz. Bu prensipler, yazılım geliştirme sürecinde takip edilmesi gereken en önemli prensiplerden bazılarıdır.

YAGNI

YAGNI prensibi, “You Ain’t Gonna Need It veya You Aren’t Gonna Need It” ifadesinin kısaltmasıdır ve Türkçe anlamı “Buna İhtiyacın Olmayacak” demektir. Yazılım geliştirme sürecinde bu prensip, gereksiz kod yazmaktan kaçınmanın önemini vurgular.

YAGNI prensibi, gelecekte belki kullanılabilecek özellikleri veya fonksiyonları şimdiden kodlamak yerine, sadece o anki ihtiyaçlara odaklanmayı önerir. Bu sayede, gereksiz kod yazarak zaman ve emek kaybı yaşanmasının önüne geçilir.

Bu prensip, kodun basit ve sade kalmasını sağlar. Bu da yazılımın daha kolay anlaşılabilir, test edilebilir ve bakımı yapılabilir hale gelmesini sağlar. Ayrıca, gereksiz kod yazımı yerine sadece ihtiyaç duyulan kod yazılarak kod kalitesi de arttırılmış olur.

Sonuç olarak, YAGNI prensibi, yazılım geliştirme sürecinde önemli bir prensiptir ve gereksiz kod yazmaktan kaçınarak, daha iyi ve sade bir kod yazımına yardımcı olur.

DRY

DRY prensibi, “Don’t Repeat Yourself” (Kendini Tekrarlama) ifadesinin kısaltmasıdır. Bu prensip, yazılım geliştirme sürecinde tekrarlanan kod bloklarından kaçınmanın önemini vurgular.

DRY prensibi, aynı kodun birden fazla yerde kullanılması yerine, bir fonksiyon ya da metot şeklinde yazılarak kodun yeniden kullanılabilirliğini artırır. Böylece, geliştiriciler aynı kodu tekrar tekrar yazmak yerine, daha önce yazdıkları kodu kullanarak zamandan tasarruf ederler.

DRY prensibi ayrıca kodun okunabilirliğini artırır. Tekrarlanan kod blokları, kodun okunmasını ve anlaşılmasını zorlaştırır. Kodda değişiklik yapmak gerektiğinde, tekrarlanan kodların değiştirilmesi gerekir ve bu da daha fazla zaman alır.

DRY prensibi, yazılım geliştirme sürecinde kodun sadeleştirilmesine yardımcı olur ve kod kalitesini artırır. Ancak, bu prensibin uygulanması, kodun yeniden kullanılabilirliğini artırırken aynı zamanda kodun doğru şekilde organize edilmesini ve bütünlüğünü korumasını gerektirir.

Sonuç olarak, DRY prensibi, yazılım geliştirme sürecinde tekrarlanan kod bloklarından kaçınmanın önemini vurgular ve kodun sadeleştirilmesine yardımcı olur. Bu prensip, kodun yeniden kullanılabilirliğini artırarak yazılım geliştirme sürecinde zaman ve emek tasarrufu sağlar.

SOC

SOC (Separation of Concerns), Türkçe’ye “Endişelerin Ayrıştırılması” olarak çevrilebilecek bir prensiptir. Yazılım geliştirme sürecinde bu prensip, farklı işlevleri olan parçaların birbirinden bağımsız olarak tasarlanmasını ve geliştirilmesini önerir.

Bu prensibe göre, bir yazılımın farklı işlevleri, kendi endişeleri ile ilgili bölümlerde düzenlenmelidir. Bir yazılımın belirli bir işlevi için geliştirilen kod blokları, sadece o işlevi yerine getirmekle ilgilenmelidir ve başka işlevleri etkilememelidir.

SOC prensibi, yazılımın daha modüler hale gelmesini sağlar. Modüler yazılım, farklı işlevleri olan parçaların birleştirilmesiyle oluşturulur. Bu sayede, her bir parça birbirinden bağımsız olarak geliştirilir ve test edilir. Bu da yazılımın daha güvenilir, okunaklı ve sürdürülebilir olmasını sağlar.

SOC prensibi ayrıca, yazılım geliştirme sürecinde yeniden kullanılabilirliği artırır. Modüler bir yaklaşım, farklı yazılım parçalarının başka projelerde veya farklı işlevlerde yeniden kullanılmasını kolaylaştırır.

Sonuç olarak, SOC prensibi, yazılımın farklı işlevleri için geliştirilen kod bloklarının birbirinden bağımsız olarak tasarlanmasını ve geliştirilmesini önerir. Bu prensip, yazılımın daha modüler hale gelmesini, daha güvenilir ve sürdürülebilir olmasını sağlar ve yazılım geliştirme sürecinde yeniden kullanılabilirliği artırır.

KISS

KISS, “Keep It Simple, Stupid veya Keep It Short and Simple” (Basit Tut, Aptal) kısaltmasının açılımıdır. Yazılım geliştirme sürecinde, bu prensip, bir tasarımın en basit haliyle tutulması gerektiğini vurgular.

KISS prensibi, yazılımın daha okunaklı, sürdürülebilir ve test edilebilir olmasını sağlar. Karmaşık tasarımlar, kodun anlaşılmasını zorlaştırır ve hataların tespit edilmesini ve giderilmesini güçleştirir.

KISS prensibi, yazılımın daha basit olmasını önerir, ancak bu, kodun işlevselliğinden ödün vermek anlamına gelmez. Tam tersine, KISS prensibi, işlevselliği ve kaliteyi artırmak için gereksiz karmaşıklıklardan kaçınmayı önerir.

KISS prensibinin uygulanması, kodun daha okunaklı hale gelmesini sağlar. Basit bir kod, geliştiricilerin kodu daha hızlı anlamasını ve değişiklik yapmasını sağlar. Ayrıca, basit bir kod, yeni geliştiricilerin projeye daha hızlı adapte olmasını sağlar.

KISS prensibi ayrıca, yazılımın daha sürdürülebilir hale gelmesini sağlar. Karmaşık kodlar, bakım ve güncelleme işlemlerini zorlaştırırken, basit kodlar daha az hata içerir ve daha kolay bakım yapılmasını sağlar.

Sonuç olarak, KISS prensibi, yazılımın en basit haliyle tutulmasını önerir. Bu prensip, yazılımın daha okunaklı, sürdürülebilir ve test edilebilir olmasını sağlar. Basit bir kod, yazılım geliştirme sürecinde hızlı ve kolay değişiklik yapılmasını sağlar ve daha az hata içerir.

LOD

LOD (Law of Demeter), yazılım geliştirme sürecinde, nesneler arasındaki bağımlılık seviyesini minimize etmeyi öneren bir prensiptir. LOD, ayrıca “Least Knowledge Principle” (En Az Bilgi Prensipleri) olarak da bilinir.

LOD prensibi, bir sınıfın diğer sınıflara mümkün olduğunca az bağımlı olması gerektiğini belirtir. Bir sınıfın sadece doğrudan bağımlı olduğu sınıflarla etkileşimde bulunması önerilir. Yani, bir sınıf, başka sınıfların başka sınıflarla olan ilişkilerinden haberdar olmamalıdır.

Bu prensibin temel amacı, yazılımın daha esnek ve yeniden kullanılabilir hale gelmesini sağlamaktır. Bir sınıfın diğer sınıflara sıkı sıkıya bağımlı olması durumunda, değişikliklerin yapılması ve yeniden kullanılabilirliğin sağlanması daha zor hale gelir.

LOD prensibi, yazılım geliştiricilerine sınıflar arasındaki bağımlılıkları azaltmak için birkaç yöntem önerir. Bunlar arasında, sınıfın diğer sınıflarla olan etkileşimini sınırlamak, sınıfın sadece kendi görevleri ile ilgili bilgiyi saklamak, ara katmanlar kullanmak ve gerekirse arayüzler kullanmak sayılabilir.

Sonuç olarak, LOD prensibi, yazılımın esnek, sürdürülebilir ve yeniden kullanılabilir olmasını sağlamak için, sınıflar arasındaki bağımlılık seviyesini minimize etmeyi önerir. Bu prensip, bir sınıfın sadece kendi görevleriyle ilgili bilgiyi saklamasını ve sadece doğrudan bağımlı olduğu sınıflarla etkileşimde bulunmasını önerir. Bu sayede, yazılım daha az hata içerecek ve daha kolay bakım yapılmasını sağlayacaktır.

SOLID

SOLID, yazılım mühendisliğinde kullanılan temel prensiplerin bir akronimididir. Bu prensipler, yazılımın daha esnek, sürdürülebilir, bakımı kolay, yeniden kullanılabilir ve genişletilebilir hale getirilmesini hedeflemektedir. İlk olarak, SOLID prensiplerini belirten Robert C. Martin (a.k.a. Uncle Bob) tarafından tanıtılmıştır.

SOLID prensipleri şunlardır:

  • S - Single Responsibility Principle (Tek Sorumluluk Prensibi)
  • O - Open/Closed Principle (Açık/Kapalı Prensibi)
  • L - Liskov Substitution Principle (Liskov Yerine Geçme Prensibi)
  • I - Interface Segregation Principle (Arayüz Ayrımı Prensibi)
  • D - Dependency Inversion Principle (Bağımlılık Tersine Çevirme Prensibi)

Bu prensipleri ayrı ayrı açıklayalım:

  1. Tek Sorumluluk Prensibi (Single Responsibility Principle): Bir sınıfın sadece bir görevi veya sorumluluğu olmalıdır. Sınıfların, farklı sorumlulukları olan diğer sınıflarla karıştırılmadan, tek bir sorumluluğa sahip olması, kodun daha okunaklı, anlaşılır ve sürdürülebilir olmasını sağlar.
  2. Açık/Kapalı Prensibi (Open/Closed Principle): Bir sınıf, değişime kapalı (closed) olmalı, ancak yeni işlevselliği eklemek için açık (open) olmalıdır. Yani, mevcut kodun değiştirilmesi gerektiğinde sınıfı değiştirmek yerine, yeni işlevselliği eklemek için genişletilebilir olmalıdır.
  3. Liskov Yerine Geçme Prensibi (Liskov Substitution Principle): Herhangi bir alt sınıf, üst sınıfın yerine geçebilmelidir. Bu, alt sınıfların, üst sınıfın davranışlarını koruması gerektiği anlamına gelir. Bu prensibin uygulanması, kodun daha esnek hale gelmesine ve yeniden kullanılabilirliğinin artmasına yardımcı olur.
  4. Arayüz Ayrımı Prensibi (Interface Segregation Principle): Bir arayüz, kullanmayacağımız özelliklere sahip olmamalıdır. Kullanılmayan özellikler, kodun gereksiz yere büyümesine ve karmaşık hale gelmesine neden olabilir. Bu nedenle, arayüzler, ihtiyaç duyulan işlevselliği kapsayacak şekilde tasarlanmalıdır.
  5. Bağımlılık Tersine Çevirme Prensibi (Dependency Inversion Principle): Yüksek seviyeli sınıflar, düşük seviyeli sınıflara bağlı olmamalıdır. Bunun yerine, her iki sınıf da soyutlamalara (abstractions) bağımlı olmalıdır. Yüksek seviyeli sınıflar, düşük seviyeli sınıfların nasıl uygulandığından bağımsız olmalıdır. Bu, kodun daha az bağımlı, daha esnek ve yeniden kullanılabilir hale gelmesini sağlar.

SOLID prensiplerinin uygulanması, yazılım projelerinin daha sürdürülebilir, esnek ve genişletilebilir olmasına yardımcı olur. Bu prensipleri takip etmek, kod kalitesini artırır ve daha az bakım gerektiren, daha az hata veren, daha hızlı geliştirilen ve daha az maliyetli yazılım projeleri oluşturmanıza olanak tanır.

Bu makalede, yazılım geliştiricilerin sıkça duyacakları YAGNI, DRY, SOC, KISS, LOD ve SOLID prensiplerini ele aldık. Bu prensipler, kodun okunabilirliğini, yeniden kullanılabilirliğini, bakımını ve genişletilebilirliğini artırmak için tasarlanmıştır. Bu prensipleri takip etmek, yazılım projelerini daha sürdürülebilir, esnek ve genişletilebilir hale getirebilir.

SOLID prensipleri, kodun esnekliğini ve yeniden kullanılabilirliğini artırırken, DRY prensibi, kodun tekrarını önleyerek yazılım projelerinin bakımını kolaylaştırır. KISS prensibi, kodun okunabilirliğini artırırken, SOC prensibi, kodu modüler ve bağımsız hale getirerek yazılım projelerini daha sürdürülebilir hale getirir. LOD prensibi, kodun daha az bağımlı hale gelmesini sağlarken, YAGNI prensibi, gereksiz kodların yazılmasını önleyerek kodun daha temiz ve okunaklı hale gelmesine yardımcı olur.

Bu prensipleri uygulamak, yazılım geliştirme sürecinde daha verimli, daha hızlı ve daha maliyet-etkin olmamıza yardımcı olabilir. Yüksek kaliteli ve esnek bir yazılım ürünü oluşturmak istiyorsak, YAGNI, DRY, SOC, KISS, LOD ve SOLID prensiplerini dikkate almamız önemlidir.

Kaynaklar