<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Erkan TURGUT on Medium]]></title>
        <description><![CDATA[Stories by Erkan TURGUT on Medium]]></description>
        <link>https://medium.com/@turguterkan55?source=rss-f138beb1eefb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZlKFgFsD0oZUV3_1j-3qjQ.png</url>
            <title>Stories by Erkan TURGUT on Medium</title>
            <link>https://medium.com/@turguterkan55?source=rss-f138beb1eefb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 06:33:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@turguterkan55/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Öğrenci Akademik Başarısını Tahmin Etmek: Uçtan Uca Bir Veri Bilimi ve Makine Öğrenmesi Projesi]]></title>
            <link>https://medium.com/@turguterkan55/%C3%B6%C4%9Frenci-akademik-ba%C5%9Far%C4%B1s%C4%B1n%C4%B1-tahmin-etmek-u%C3%A7tan-uca-bir-veri-bilimi-ve-makine-%C3%B6%C4%9Frenmesi-projesi-6ba1b69c59ca?source=rss-f138beb1eefb------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ba1b69c59ca</guid>
            <dc:creator><![CDATA[Erkan TURGUT]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 22:52:31 GMT</pubDate>
            <atom:updated>2026-08-15T22:52:31.131Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Türkiye Yapay Zeka Akademisi x Huawei Student Developers — Veri Bilimi ve Makine Öğrenmesi Bootcamp Final Projesi</strong></p><blockquote>Giriş: Neden Bu Problemi Seçtim</blockquote><p>Üç haftalık bootcamp boyunca Python temellerinden başlayıp veri temizleme, keşifsel analiz ve makine öğrenmesi algoritmalarına kadar uzanan bir yol izledik. Final projesi için öğrendiklerimi tek bir akışta birleştirebileceğim, hem sezgisel hem de eğitim alanında gerçek karşılığı olan bir problem seçmek istedim: <em>öğrenci akademik başarısının tahmin edilmesi.</em></p><p>Eğitim kurumları için &quot;hangi öğrenci risk altında?&quot; sorusunu erken cevaplayabilmek, müdahale kaynaklarını doğru yere yönlendirmek açısından değerli. Bu proje, o sorunun küçük ölçekli bir simülasyonu.</p><blockquote><strong>Araştırma Sorusu: </strong>Bir öğrencinin çalışma alışkanlıkları, devam durumu, uyku düzeni, geçmiş akademik performansı ve yarı zamanlı iş durumu bilindiğinde, dersi geçip geçmeyeceğini ne kadar doğrulukla tahmin edebiliriz — ve bu tahminde en belirleyici faktörler hangileri?</blockquote><p>Bu, klasik bir <strong>ikili sınıflandırma (binary classification)</strong> problemi: hedef değişken `gecti_mi` (0 = kaldı, 1 = geçti).</p><h3>1. Veri Seti Tanıtımı</h3><p>Proje için 500 öğrenciye ait, 5 bağımsız değişken ve 1 hedef değişken içeren bir veri seti kullandım.</p><p>| Değişken | Açıklama | Tip |<br>|---|---|---|<br>| `calisma_saati` | Haftalık ders çalışma süresi (saat) | Sayısal |<br>| `devam_orani` | Derse katılım yüzdesi | Sayısal |<br>| `uyku_saati` | Günlük ortalama uyku süresi | Sayısal |<br>| `onceki_not` | Önceki dönem not ortalaması | Sayısal |<br>| `yari_zamanli_is` | Yarı zamanlı işte çalışıyor mu | Kategorik (0/1) |<br>| `final_notu` | Hesaplanan final notu | Sayısal (yardımcı) |<br>| `gecti_mi` | **Hedef değişken** — final_notu ≥ 50 ise 1 | Kategorik (0/1) |</p><p>İlk incelemede dikkat ettiğim noktalar:</p><p>- 500 satır, **hiç eksik veri yok** — bu gerçek dünya veri setlerinde nadir görülen bir durum, genellikle `isnull().sum()` ile kontrol edip `fillna()` veya `dropna()` gerekir<br>- Sınıf dağılımı **%78.2 geçti / %21.8 kaldı** — yani hafif dengesiz (imbalanced) bir veri seti; bu durum ileride recall/precision yorumunu doğrudan etkileyecek<br>- Sayısal değişkenlerin aralıkları farklı ölçeklerde (çalışma saati 0-12, devam oranı 30-100) — bu da ön işlemede standardizasyonu zorunlu kılıyor</p><p>```python<br>df.describe()<br>df.isnull().sum()<br>df[&quot;gecti_mi&quot;].value_counts(normalize=True)<br>```</p><p>## 2. Keşifsel Veri Analizi (EDA)</p><p>### 2.1 Final Notu Dağılımı</p><p>İlk adım olarak hedef değişkenin türetildiği ham skorun dağılımına baktım. Histogram, notların 50-70 bandında yığıldığını, geçme sınırının (kırmızı kesikli çizgi) altında kalan kısmın nispeten ince bir kuyruk oluşturduğunu gösteriyor.</p><p>**[Grafik 1 — grafik1_dagilim.png]**</p><p>Bu dağılım şekli, veri setinin neden dengesiz olduğunu da görsel olarak açıklıyor: kaldı sınıfı, dağılımın sol tarafında az sayıda öğrenciyle temsil ediliyor.</p><p>### 2.2 Korelasyon Analizi</p><p>Değişkenler arasındaki doğrusal ilişkileri görmek için korelasyon matrisi çıkardım. Bu adım, hangi özelliklerin modelde işe yarayabileceği konusunda ilk sinyalleri veriyor.</p><p>**[Grafik 2 — grafik2_korelasyon.png]**</p><p>Gözlemler:</p><p>- `calisma_saati` ve `final_notu` arasında en güçlü pozitif korelasyon var<br>- `onceki_not` da beklendiği gibi pozitif ilişkili — geçmiş performans gelecek performansın iyi bir göstergesi<br>- `yari_zamanli_is` tek negatif korelasyona sahip değişken<br>- Bağımsız değişkenler kendi aralarında yüksek korelasyona sahip değil, yani **çoklu doğrusal bağlantı (multicollinearity)** riski düşük — bu, lojistik regresyon katsayılarının güvenilir yorumlanabileceği anlamına geliyor</p><p>### 2.3 Çalışma Saati – Final Notu İlişkisi</p><p>Tek değişkenli ilişkiyi daha net görmek için scatter plot çizdim, sınıfları renklendirdim.</p><p>**[Grafik 3 — grafik3_scatter.png]**</p><p>4-5 saatin üzerinde çalışan öğrencilerin büyük çoğunluğunun (yeşil noktalar) geçtiği açıkça görülüyor. Ancak grafik aynı zamanda çalışma saatinin **tek başına yeterli olmadığını** da gösteriyor — düşük çalışma saatinde geçen, yüksek çalışma saatinde kalan öğrenciler de var. Bu, modelin neden çok değişkenli olması gerektiğinin görsel kanıtı.</p><p>## 3. Veri Ön İşleme</p><p>Ham veriyi modele vermeden önce şu adımları uyguladım:</p><p>1. **Aykırı değer kontrolü** — `clip()` ile mantıksız değerler (ör. negatif çalışma saati, 100&#39;ün üzerinde devam oranı) makul sınırlara çekildi<br>2. **Özellik / hedef ayrımı** — `X` (5 bağımsız değişken) ve `y` (`gecti_mi`) ayrıldı<br>3. **Train/test bölünmesi** — `%80 eğitim / %20 test`, `stratify=y` parametresiyle sınıf oranı her iki sette de korundu<br>4. **Standardizasyon** — `StandardScaler` ile tüm sayısal değişkenler ortalama 0, standart sapma 1 olacak şekilde ölçeklendirildi</p><p>```python<br>X_train, X_test, y_train, y_test = train_test_split(<br> X, y, test_size=0.2, random_state=42, stratify=y<br>)</p><p>scaler = StandardScaler()<br>X_train_s = scaler.fit_transform(X_train)<br>X_test_s = scaler.transform(X_test)<br>```</p><p>**Standardizasyonun neden gerekli olduğu:** Lojistik regresyon ve KNN gibi mesafe/gradyan temelli algoritmalar, farklı ölçeklerdeki değişkenlere farklı ağırlık verebilir. Örneğin `devam_orani` (0-100) ölçeklenmezse, `uyku_saati` (3-10) gibi değişkenleri gölgede bırakabilir — oysa gerçek etkileri bu değil.</p><p>## 4. Model Kurma ve Karşılaştırma</p><p>Tek bir modelle yetinmek yerine iki farklı yaklaşımı karşılaştırdım: **Lojistik Regresyon** (yorumlanabilir, doğrusal) ve **KNN** (yorumlanabilirlik daha düşük, doğrusal olmayan ilişkileri de yakalayabilen).</p><p>### 4.1 Lojistik Regresyon</p><p>```python<br>model = LogisticRegression()<br>model.fit(X_train_s, y_train)<br>y_pred = model.predict(X_test_s)<br>```</p><p>| Metrik | Değer |<br>|---|---|<br>| Accuracy | %79.0 |<br>| Precision | %82.0 |<br>| Recall | %93.6 |<br>| F1-Score | %87.4 |</p><p>**[Grafik 4 — grafik4_confusion.png]**</p><p>**Metriklerin yorumu** (bu kısmı bootcamp&#39;te en çok önemsediğim konu oldu — metrik isimlerini ezberlemek değil, ne anlama geldiğini kavramak):</p><p>- **Precision (%82):** Model &quot;geçti&quot; dediğinde, gerçekten geçme ihtimali %82<br>- **Recall (%93.6):** Gerçekten geçen öğrencilerin %93.6&#39;sını model doğru yakalıyor<br>- **Neden Recall &gt; Precision?** Veri setindeki sınıf dengesizliği (%78 geçti) nedeniyle model, &quot;geçti&quot; sınıfını tahmin etmeye daha yatkın — bu yüzden geçenleri yakalamada güçlü, ama kalanların bir kısmını da yanlışlıkla &quot;geçti&quot; olarak işaretliyor (confusion matrix&#39;teki 16 yanlış pozitif)</p><p>### 4.2 KNN ve Hiperparametre Optimizasyonu</p><p>İkinci model olarak K-Nearest Neighbors&#39;ı denedim. Önce varsayılan k=5 ile, sonra `GridSearchCV` ile en iyi k değerini arayarak.</p><p>```python<br>knn = KNeighborsClassifier(n_neighbors=5)<br>knn.fit(X_train_s, y_train)</p><p>param_grid = {&quot;n_neighbors&quot;: range(1, 21)}<br>grid = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5, scoring=&quot;accuracy&quot;)<br>grid.fit(X_train_s, y_train)<br>```</p><p>**[Grafik 7 — grafik7_knn_optimizasyon.png]**</p><p>Grid search sonucunda **en iyi k=11** olarak bulundu (5-fold CV skoru: %82.5). Grafikteki eğri, k arttıkça modelin başta iyileştiğini, sonrasında düzleştiğini gösteriyor — bu, klasik bir bias-variance trade-off örneği: düşük k (ör. k=1) overfitting&#39;e, çok yüksek k ise underfitting&#39;e yatkın.</p><p>### 4.3 Model Karşılaştırması</p><p>**[Grafik 6 — grafik6_model_karsilastirma.png]**</p><p>| Model | Test Accuracy | F1-Score |<br>|---|---|---|<br>| Lojistik Regresyon | %79.0 | %87.4 |<br>| KNN (k=5, varsayılan) | %83.0 | %89.8 |<br>| KNN (k=11, optimize) | %81.0 | — |</p><p>Bu veri setinde KNN, varsayılan parametrelerle bile Lojistik Regresyon&#39;u geçti. Ancak tek bir train/test bölünmesine güvenmemek için **5-fold cross-validation** da uyguladım:</p><p>```python<br>cv_scores = cross_val_score(LogisticRegression(), X_train_s, y_train, cv=5)<br># Ortalama Accuracy: %80.5, Std: 0.036<br>```</p><p>CV sonucu, tek seferlik test skorunun (79%) şans eseri düşük çıkmadığını, modelin genel performansının %80 civarında istikrarlı olduğunu doğruladı.</p><p>## 5. Özellik Önemi: Hangi Faktör En Çok Etkiliyor?</p><p>Lojistik regresyon katsayılarına (standardize edilmiş) baktığımda:</p><p>**[Grafik 5 — grafik5_ozellik_onemi.png]**</p><p>1. **Çalışma saati (+1.20)** — en güçlü pozitif etki<br>2. **Uyku saati (+0.71)** — pozitif etki<br>3. **Devam oranı (+0.57)** — pozitif etki<br>4. **Önceki not (+0.31)** — pozitif ama görece zayıf etki<br>5. **Yarı zamanlı iş (-0.71)** — tek negatif etkili değişken, çalışma saatine yakın büyüklükte</p><p>Burada dikkat çeken nokta: **önceki notun** etkisinin beklediğimden zayıf çıkması. Bu, mevcut dönemdeki davranışsal faktörlerin (çalışma, uyku, devam) geçmiş performanstan daha belirleyici olabileceğine işaret ediyor — tabii bu sentetik veri setinin kurgusundan kaynaklanan bir sonuç, gerçek veri ile doğrulanması gerekir.</p><p>## 6. Sınırlılıklar</p><p>Bu projeyi dürüstçe değerlendirmek gerekirse:</p><p>- Veri seti **sentetik olarak üretildi** (gerçek bir okuldan toplanmadı), bu yüzden bulgular gerçek dünya için doğrudan genellenemez<br>- 500 satır, güçlü bir model için sınırlı bir örneklem büyüklüğü<br>- Sadece 5 özellik kullanıldı; gerçek bir senaryoda sosyoekonomik durum, ders zorluğu, öğretmen etkisi gibi değişkenler de önemli olurdu<br>- Sınıf dengesizliği ele alınmadı (SMOTE veya `class_weight=&quot;balanced&quot;` denenebilirdi)</p><p>## 7. Sonuç ve Öğrenilenler</p><p>Bu proje bana veri bilimi sürecinin uçtan uca nasıl işlediğini gösterdi: **ham veriyi anlamak → temizlemek → görselleştirerek örüntü aramak → modele uygun hale getirmek → birden fazla model kurup karşılaştırmak → cross-validation ile doğrulamak.**</p><p>En önemli çıkarımım: **tek bir accuracy sayısına güvenmemek.** Precision/recall dengesini anlamadan, cross-validation yapmadan çıkan tek bir sonuç yanıltıcı olabiliyor. KNN&#39;in Lojistik Regresyon&#39;dan daha iyi görünmesi bile, veri setinin büyüklüğü göz önüne alındığında temkinli yorumlanmalı.</p><p>İleri adım olarak Random Forest veya XGBoost gibi ağaç tabanlı modellerle, ayrıca gerçek bir eğitim kurumu veri setiyle bu analizi tekrarlamayı planlıyorum.</p><p>---</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ba1b69c59ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JAVA CONCURRENCY]]></title>
            <link>https://medium.com/@turguterkan55/java-concurrency-5804d85ce388?source=rss-f138beb1eefb------2</link>
            <guid isPermaLink="false">https://medium.com/p/5804d85ce388</guid>
            <category><![CDATA[threading]]></category>
            <category><![CDATA[java-multithreading]]></category>
            <category><![CDATA[java8]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[java-concurrency]]></category>
            <dc:creator><![CDATA[Erkan TURGUT]]></dc:creator>
            <pubDate>Fri, 13 Jun 2025 15:28:22 GMT</pubDate>
            <atom:updated>2025-06-13T15:28:22.228Z</atom:updated>
            <content:encoded><![CDATA[<p>Java’da <strong>concurrency </strong>(eşzamanlılık), birden fazla iş parçacığının (thread) aynı anda çalışarak kaynakları paylaşmasını ve programın performansını artırmasını sağlayan güçlü bir özelliktir. Ancak bu, karmaşıklık ve dikkatli yönetim gerektirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RXZ79KrlAPPdPWJD" /><figcaption>Photo by <a href="https://unsplash.com/@lucabravo?utm_source=medium&amp;utm_medium=referral">Luca Bravo</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Concurrency</strong>, modern programlamanın en heyecan verici ama bir o kadar da zorlayıcı yönlerinden biridir. Bir restoranda aynı anda yemek hazırlayan birden fazla şef düşünün: Biri salata doğrar, diğeri et pişirir, bir başkası tatlı hazırlar. Hepsi aynı mutfağı (kaynakları) paylaşır, ancak bir bıçağı aynı anda kapmamak için dikkatli olmaları gerekir. İşte Java’daki concurrency de böyledir: Birden fazla <strong>thread</strong>, aynı anda çalışır, kaynakları paylaşır ve uyum içinde iş yapar (ya da yapmalıdır!).</p><p>Java’da concurrency, <strong>thread</strong>’ler aracılığıyla uygulanır. Her Java uygulaması en az bir thread (main thread) ile başlar, ancak ek thread’ler oluşturarak birden fazla görevi paralel olarak yürütebilirsiniz. Bu yazıda, thread oluşturmaktan senkronizasyona, Java’nın güçlü `<strong><em>java.util.concurrent</em></strong>` araçlarından yaygın sorunlara kadar her şeyi adım adım ele alacağız.</p><h3>Concurrency Nedir ve Neden Önemlidir?</h3><p>Concurrency, bir programın birden fazla görevi aynı anda (veya görünüşte aynı anda) yürütmesini sağlar. Bir restoran örneğiyle düşünelim: Müşterilere hızlı hizmet vermek için garsonlar sipariş alırken, şefler yemek hazırlar ve bulaşıkçılar tabakları temizler. Bu paralel iş akışı, restoranın verimliliğini artırır. Java’da da concurrency şu avantajları sunar:</p><p>- <strong>Performans</strong>: Çok çekirdekli işlemcilerden tam verim alarak işlemleri hızlandırır.<br>- <strong>Kullanıcı Deneyimi</strong>: Uzun süren işlemler (örneğin, dosya indirme) ana thread’i bloke etmez, böylece uygulama responsive kalır.<br>- <strong>Kaynak Kullanımı</strong>: CPU ve I/O kaynaklarını daha etkin kullanır.</p><p>Ancak concurrency, bazı tuzaklarla bize gelir:<br>- <strong>Race Condition</strong>: Birden fazla thread aynı kaynağı aynı anda değiştirdiğinde hatalar meydana geebiliyor.<br>- <strong>Deadlock</strong>: Thread’ler birbirini kilitleyerek tıkanabilir.<br>- <strong>Performans Sorunları</strong>: Yanlış yönetim, fazla kullanım kaynak israfına yol açabilir bu da programın verimliliğine zarar verir.</p><p>Hadi, Java’nın concurrency araçlarını keşfederek bu zorlukların üstesinden gelelim :)</p><h3>Java’da Thread Oluşturma</h3><p>Java’da thread oluşturmanın iki ana yolu vardır: `<strong><em>Thread</em></strong>` sınıfını genişletmek veya `<strong><em>Runnable</em></strong>` arayüzünü uygulamak. Her ikisini de restoran metaforuyla açıklayalım.</p><h4><strong>1. Thread Sınıfını Genişletme</strong></h4><p>Bir thread oluşturmak için `<em>Thread</em>` sınıfını genişletebilir ve `<em>run()</em>` metodunu override ederek thread’in yapacağı işi tanımlayabilirsiniz. Bu, bir şefin kendine özgü bir yemek hazırlama rutini oluşturması gibidir.</p><p><strong><em>Örnekle açıklayalım:</em></strong></p><pre>class ChefThread extends Thread {<br> @Override<br> public void run() {<br> for (int i = 1; i &lt;= 3; i++) {<br> System.out.println(getName() + &quot; yemek &quot; + i + &quot;&#39;i hazırlıyor&quot;);<br> try {<br> Thread.sleep(1000); // Yemek hazırlama süresini simüle et<br> } catch (InterruptedException e) {<br> e.printStackTrace();<br> }<br> }<br> }<br>}<br>public class Kitchen {<br> public static void main(String[] args) {<br> ChefThread chef1 = new ChefThread();<br> ChefThread chef2 = new ChefThread();<br> chef1.start(); // İlk şefi başlat<br> chef2.start(); // İkinci şefi başlat<br> }<br>}<br><br>//Çıktı:<br>/*<br>Thread-0 yemek 1&#39;i hazırlıyor<br>Thread-1 yemek 1&#39;i hazırlıyor<br>Thread-0 yemek 2&#39;i hazırlıyor<br>Thread-1 yemek 2&#39;i hazırlıyor<br>*/<br></pre><p>Şimdi açıklayalım:<br>- `<strong><em>run()</em></strong>` metodu, thread’in iş mantığını içerir.<br>- `<strong><em>start()</em></strong>` metodu, JVM’ye thread’i çalıştırmasını söyler. Bu, şefin mutfakta çalışmaya başlaması gibidir.<br>- Çıktılar karışık görünebilir çünkü thread’ler bağımsız çalışır ve işletim sistemi onların sırasını belirler.(join ile bekletme kısmını ilerde anlatacağım)</p><h4><strong>2. Runnable Arayüzünü Uygulama</strong></h4><p>`<strong>Runnable</strong>` arayüzü, daha esnek bir yaklaşımdır çünkü Java’da bir sınıf sadece bir sınıfı genişletebilir.(<em>Runnable arayüzü ile beraber uygulamak istediğmiz farklı arayüzler de olabilir</em>) `<strong><em>Runnable</em></strong>` ile bir görev tanımlar ve bunu bir `<strong><em>Thread</em></strong>` nesnesine veririz. Bu, bir garsonun belirli bir sipariş listesini takip etmesi gibidir.</p><p><strong><em>Örnekle açıklayalım:</em></strong></p><pre>class WaiterTask implements Runnable {<br> @Override<br> public void run() {<br> for (int i = 1; i &lt;= 3; i++) {<br> System.out.println(Thread.currentThread().getName() + &quot; masa &quot; + i + &quot;&#39;e servis yapıyor&quot;);<br> try {<br> Thread.sleep(1000);<br> } catch (InterruptedException e) {<br> e.printStackTrace();<br> }<br> }<br> }<br>}<br>public class Restaurant {<br> public static void main(String[] args) {<br> Thread waiter1 = new Thread(new WaiterTask());<br> Thread waiter2 = new Thread(new WaiterTask());<br> waiter1.start();<br> waiter2.start();<br> }<br>}</pre><p>Bunu şöyle açıklayabiliriz:<br>✅ `<strong><em>Runnable</em></strong>` sadece `run()` metodunu tanımlar. Bir `Thread` nesnesine `<strong><em>Runnable</em></strong>`’ı vererek thread oluşturursunuz.<br>✅Bu yöntem, sınıfın başka bir sınıfı genişletmesine izin verdiği için daha yaygın kullanılır. Örneğin, garson sınıfınız başka bir rolden (örneğin, `<em>Employee</em>`) türeyebilir.</p><h4>Senkronizasyon: Thread’leri Uyum İçinde Tutmak</h4><p>Birden fazla thread aynı kaynağı (örneğin, bir değişken veya nesne) paylaştığında, *<strong><em>race condition</em></strong>* gibi sorunlar ortaya çıkabilir. Restoranımızda, iki garsonun aynı tabak sayacını aynı anda artırmaya çalıştığını düşünün — bazı tabaklar sayılmadan kaybolabilir!!! Java, bu sorunu *<em>senkronizasyon</em>* ile çözer.</p><p><strong><em>Örnek: Paylaşılan Bir Sayaç</em></strong></p><p>Restoranımızda servis edilen tabak sayısını takip eden bir sayaç düşünelim. Senkronizasyon olmadan, birden fazla thread’in aynı sayacı artırması hatalara yol açar.</p><p>Hatalı Kod‼️</p><pre>class DishCounter {<br> private int dishesServed = 0;<br>public void serveDish() {<br> dishesServed++; // Thread-safe değil!<br> }<br>public int getDishesServed() {<br> return dishesServed;<br> }<br>}<br>public class Restaurant {<br> public static void main(String[] args) throws InterruptedException {<br> DishCounter counter = new DishCounter();<br>Runnable task = () -&gt; {<br> for (int i = 0; i &lt; 1000; i++) {<br> counter.serveDish();<br> }<br> };<br>Thread waiter1 = new Thread(task);<br> Thread waiter2 = new Thread(task);<br> waiter1.start();<br> waiter2.start();<br> waiter1.join(); // Waiter1&#39;in bitmesini bekle<br> waiter2.join(); // Waiter2&#39;nin bitmesini bekle<br>System.out.println(&quot;Toplam servis edilen tabak: &quot; + counter.getDishesServed());<br> }<br>}</pre><p>Sorun❗: `<em>dishesServed++</em>` işlemi atomik değildir (okuma, artırma, yazma adımları içerir). İki thread aynı anda bu işlemi yaparsa, bazı artışlar kaybolabilir ve çıktı 2000’den küçük olabilir (örneğin, 1998).</p><p>Şöyle çözüm yapabilriz: <strong><em>Synchronized Metot</em></strong></p><p>`<strong>synchronized</strong>` anahtar kelimesi, aynı anda sadece bir thread’in metoda erişmesini sağlar:</p><pre>class DishCounter {<br> private int dishesServed = 0;<br>public synchronized void serveDish() {<br> dishesServed++;<br> }<br>public int getDishesServed() {<br> return dishesServed;<br> }<br>}<br><br>/*<br>*Çıktı: `Toplam servis edilen tabak: 2000`<br>*/</pre><p>Açıklama: `<strong>synchronized</strong>`, `<strong>DishCounter</strong>` nesnesi üzerinde bir kilit oluşturur. Bu, sadece bir garsonun sayacı artırmasına izin verir, diğerleri bekler. Restoranda bir fırını tek şefin kullanması gibi.</p><p><strong><em>Synchronized Bloklar ile İnce Ayar</em></strong></p><p>Performans için sadece kritik kodu senkronize edebilirsiniz:</p><pre>class DishCounter {<br> private int dishesServed = 0;<br>public void serveDish() {<br> synchronized (this) {<br> dishesServed++;<br> }<br> }<br>public int getDishesServed() {<br> return dishesServed;<br> }<br>}<br></pre><p><strong>Açıklama</strong>: Bu, sadece `<em>dishesServed++</em>` işlemini kilitler, böylece kilit kapsamı küçülür ve performans artar. Bu, fırının sadece pişirme anında kilitlenmesi gibidir.</p><blockquote>👉🏻java.util.concurrent: Modern Concurrency Araçları</blockquote><p>Java’nın düşük seviyeli thread yönetimi güçlü olsa da, <em>java.util.concurrent</em> paketi daha yüksek seviyeli ve kullanımı kolay araçlar sunar. Bu, mutfağınıza iş bir ekip ve profesyonel ekipmanlar getirmek gibidir.</p><h4>1. ExecutorService: Thread Havuzları ile Çalışma</h4><p>Her görev için manuel thread oluşturmak yerine, `ExecutorService` ile bir thread havuzu oluşturabilirsiniz. Bu, şeflerden oluşan bir ekibi yönetip işleri sırayla atamak gibidir.</p><p>Örnekle şöyle bakabiliriz:</p><pre>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br>public class BusyKitchen {<br> public static void main(String[] args) {<br> ExecutorService kitchenStaff = Executors.newFixedThreadExecutor(2); // 2 thread&#39;li havuz<br>Runnable task = () -&gt; {<br> for (int i = 1; i &lt;= 3; i++) {<br> System.out.println(Thread.currentThread().getName() + &quot; yemek &quot; + i + &quot;&#39;i hazırlıyor&quot;);<br> try {<br> Thread.sleep(1000);<br> } catch (InterruptedException e) {<br> e.printStackTrace();<br> }<br> }<br> };<br>kitchenStaff.submit(task);<br> kitchenStaff.submit(task);<br> kitchenStaff.shutdown(); // Yeni görevleri durdur<br> }<br>}<br></pre><p><strong><em>Açıklama:</em></strong><br>- <strong>newFixedThreadPool(2)</strong>: 2 thread’lik bir havuz oluşturur.<br>- <strong>submit()</strong>: Görevleri havuza gön derir, havuz uygun thread’i seçer.<br>- <strong>shutdown()</strong>: Yeni görev kabulünü durdurur. Bu, vardiyanın sonunda mutfağı kapatmak gibidir.</p><h4>2. BlockingQueue: Üretici-Tüketici Modeli</h4><p><strong>BlockingQueue</strong>, bir thread’in veri ürettiği (producer) ve başka bir thread’in veri tükettiği (consumer) senaryolar için idealdir. Şeflerin yemek yapıp garsonların servis yapması gibi.</p><p>Örnek:</p><pre>```java<br>import java.util.concurrent.ArrayBlockingQueue;<br>import java.util.concurrent.BlockingQueue;<br>public class RestaurantQueue {<br> public static void main(String[] args) {<br> BlockingQueue&lt;String&gt; orderQueue = new ArrayBlockingQueue&lt;&gt;(3);<br>// Şef (Producer)<br> Runnable chef = () -&gt; {<br> try {<br> orderQueue.put(&quot;Pizza&quot;);<br> orderQueue.put(&quot;Makarna&quot;);<br> orderQueue.put(&quot;Salata&quot;);<br> } catch (InterruptedException e) {<br> e.printStackTrace();<br> }<br> };<br>// Garson (Consumer)<br> Runnable waiter = () -&gt; {<br> try {<br> System.out.println(&quot;Servis: &quot; + orderQueue.take());<br> System.out.println(&quot;Servis: &quot; + orderQueue.take());<br> System.out.println(&quot;Servis: &quot; + orderQueue.take());<br> } catch (InterruptedException e) {<br> e.printStackTrace();<br> }<br> };<br>new Thread(chef).start();<br> new Thread(waiter).start();<br> }<br>}<br>```<br>/*<br>Çıktı:<br><br>Servis: Pizza<br>Servis: Makarna<br>Servis: Salata<br>*/<br></pre><p><strong>Açıklama:</strong><br>- <strong>BlockingQueue,</strong> thread-safe bir kuyruktur. <strong>put() </strong>veri ekler, <strong>take() </strong>veri alır.<br>- Eğer kuyruk doluysa <strong>put()</strong> bekler; boşsa <strong>take() </strong>bekler. Bu, şeflerin ve garsonların uyum içinde çalışmasını sağlar.</p><h4><strong>Sonuç</strong></h4><p>Java’da <em>concurrency</em>, uygulamalarınızı daha hızlı ve kullanıcı dostu hale getirmenin anahtarıdır. Thread oluşturma, senkronizasyon ve `java.util.concurrent` araçlarıyla, karmaşık görevleri güvenli ve verimli bir şekilde yönetebilirsiniz. Restoran metaforumuzu hatırlayın: İyi bir mutfak, şeflerin ve garsonların uyum içinde çalıştığı yerdir. Java’nın concurrency araçları, sizin bu uyumu sağlamanız için gereken her şeyi sunar.</p><p>Bu yazıda elimden geldiğinde sade haliyle sizlere bu konuyu anlatmaya çalıştım, umarım faydalı olmuştur.</p><p>Sağlıkla, kodla kalın :)</p><p><a href="http://www.linkedin.com/in/erkanturgut1205">Erkan TURGUT</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5804d85ce388" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Asenkron Programlama Nedir? JavaScript ve Python’da Nasıl Kullanılır?]]></title>
            <link>https://medium.com/@turguterkan55/asenkron-programlama-nedir-javascript-ve-pythonda-nas%C4%B1l-kullan%C4%B1l%C4%B1r-2eff39f85370?source=rss-f138beb1eefb------2</link>
            <guid isPermaLink="false">https://medium.com/p/2eff39f85370</guid>
            <category><![CDATA[asyncio]]></category>
            <category><![CDATA[asyncawait]]></category>
            <category><![CDATA[asenkron-programlama]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Erkan TURGUT]]></dc:creator>
            <pubDate>Fri, 07 Mar 2025 17:50:49 GMT</pubDate>
            <atom:updated>2025-03-07T18:03:08.604Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aBtnGYoDHl0Htxu57e55Dw.png" /></figure><p>Asenkron programlama, özellikle modern yazılım geliştirmede oldukça önemli bir konu. Eğer sen de zaman zaman “<em>Kodum neden bu kadar yavaş çalışıyor?</em>” veya “Bu işlem neden diğerlerini blokluyor?” diye düşündüysen, asenkron programlama tam senlik. Bugün bu yazıda hem teorisini hem de JavaScript ve Python’da nasıl kullanıldığını anlatacağım. Haydi başlayalım🚀</p><h4>İlk olarak Asenkron Programlama Nedir?</h4><p>Klasik programlamada, işlemler sırasıyla çalışır. Bir işlem tamamlanmadan diğeri başlayamaz. Buna “<strong>senkron programlama”</strong> diyoruz. Ama bazen uzun süren işlemler (örneğin bir API çağrısı veya dosya okuma) programın akışını durdurur. İşte burada <strong>asenkron programlama</strong> devreye girer. Asenkron programlama sayesinde, uzun süren işlemler beklenirken diğer kodlar çalışmaya devam eder. Daha iyi anlaşılması açısından gerçek hayattan bir örnek üzerinden şöyle açıklayabilirim:</p><h4>Gerçek Hayattan Örnek 🚦</h4><p>Diyelim ki bir kahve dükkanındasın ve kahve sipariş ettin. Barista senin kahveyi hazırlamaya başlamadan sıradaki diğer müşterilerle ilgilenmiyorsa, bu <strong>senkron</strong> bir süreçtir. Ama barista siparişini aldıktan sonra arkada kahveyi hazırlarken diğer müşterilerle ilgileniyorsa, bu <strong>asenkron</strong> bir süreçtir.(<em>Aynı anda birden fazla iş yapabilme👀</em>)</p><p>Aynı mantık programlamada da geçerli.</p><h3>JavaScript’te Asenkron Programlama✅</h3><blockquote>JavaScript, <strong>tek iş parçacıklı</strong> (single-threaded) bir dildir. Ancak <strong>asenkron programlama</strong> sayesinde, uzun süren işlemler (örneğin API istekleri) programı durdurmaz.</blockquote><h4>Callback Fonksiyonları:</h4><p>Callback’ler, asenkron işlemler tamamlandığında çağrılan fonksiyonlardır. Ancak <strong>callback hell</strong> denilen iç içe geçmiş fonksiyonlar kodu okunamaz hale getirebilir.</p><pre>console.log(&quot;1. İşlem başlıyor...&quot;);<br>setTimeout(() =&gt; {<br>    console.log(&quot;2. İşlem tamamlandı! (3 saniye sonra)&quot;);<br>}, 3000);<br>console.log(&quot;3. İşlem devam ediyor...&quot;);</pre><blockquote><em>çıktı:</em></blockquote><pre>1. İşlem başlıyor...<br>3. İşlem devam ediyor...<br>2. İşlem tamamlandı! (3 saniye sonra)</pre><p>Gördüğün gibi, <strong>2. işlem</strong> beklerken <strong>3. işlem</strong> devam ediyor. İşte asenkron programlamayı böyle anlayabiliriz. 1–3. işlemler yapılırken aynı zamanda 2. işlem de yapılıyor✨ Peki daha temiz ve anlaşılır halde nasıl kullanabiliriz ?</p><h4>“Promises” ile Daha Temiz Kod</h4><p>Promise, işlemler tamamlandığında (<em>başarı veya hata durumunda</em>) dönen bir yapıdır. <strong>.then() ve .catch()</strong> metodlarıyla yönetilir.</p><pre>function siparisHazirla() {<br>    return new Promise((resolve, reject) =&gt; {<br>        setTimeout(() =&gt; {<br>            resolve(&quot;Kahven hazır! ☕&quot;);<br>        }, 3000);<br>    });<br>}<br><br>siparisHazirla().then((mesaj) =&gt; {<br>    console.log(mesaj);<br>}).catch((hata) =&gt; {<br>    console.log(&quot;Hata oluştu:&quot;, hata);<br>});</pre><h4>Async-Await: Daha Okunaklı Kod</h4><p>async fonksiyonlar içinde await kullanarak, işlemlerin tamamlanmasını bekleyebiliriz.</p><pre>async function kahveAl() {<br>    console.log(&quot;Kahve sipariş ediliyor...&quot;);<br>    let sonuc = await siparisHazirla();<br>    console.log(sonuc);<br>    console.log(&quot;Afiyet olsun! 🍵&quot;);<br>}<br><br>kahveAl();</pre><blockquote>çıktı:</blockquote><pre>Kahve sipariş ediliyor...<br>(Kısa bir bekleyiş 🕒)<br>Kahven hazır! ☕<br>Afiyet olsun! 🍵</pre><p>Bu yöntem, asenkron kodları <strong>senkron kod gibi okunabilir hale getiriyor.</strong> Promise ve Async- Await kullanımını asenkron programlamada çok sık kullanırız.</p><h3>Python’da Asenkron Programlama✅</h3><blockquote>Python’da asenkron programlama için “<strong>asyncio”</strong> kütüphanesi kullanılır.</blockquote><h4>Basit Asenkron Fonksiyonlar🔎</h4><pre>import asyncio<br><br>async def siparis_ver():<br>    print(&quot;Sipariş alındı...&quot;)<br>    await asyncio.sleep(3)  # 3 saniye bekler<br>    print(&quot;Sipariş hazır! ☕&quot;)<br><br>asyncio.run(siparis_ver())</pre><p>Burada async def ile bir asenkron fonksiyon tanımlıyoruz ve await asyncio.sleep(3) ile 3 saniye bekleyerek işlemi simüle ediyoruz.</p><h4>Birden Fazla İşlemi Paralel Çalıştırmak⏩</h4><p>Diyelim ki aynı anda birden fazla sipariş almak istiyorsun. Normalde bir işlem bitmeden diğeri başlamazdı, ama <strong>asenkron programlama sayesinde aynı anda çalıştırabiliriz. (</strong><em>C# gibi dillerde multi-threads kavramını düşünebilirsiniz</em><strong>).</strong></p><pre>import asyncio<br><br>async def siparis_ver(musteri):<br>    print(f&quot;{musteri} sipariş verdi...&quot;)<br>    await asyncio.sleep(3)<br>    print(f&quot;{musteri} kahvesini aldı! ☕&quot;)<br><br>async def main():<br>    await asyncio.gather(<br>        siparis_ver(&quot;Müşteri 1&quot;),<br>        siparis_ver(&quot;Müşteri 2&quot;),<br>        siparis_ver(&quot;Müşteri 3&quot;)<br>    )<br><br>asyncio.run(main())</pre><blockquote>çıktı:</blockquote><pre>Müşteri 1 sipariş verdi...<br>Müşteri 2 sipariş verdi...<br>Müşteri 3 sipariş verdi...<br>(3 saniye bekleme)<br>Müşteri 1 kahvesini aldı! ☕<br>Müşteri 2 kahvesini aldı! ☕<br>Müşteri 3 kahvesini aldı! ☕</pre><p>Çıktıya bakarsak siparişlerin <strong>aynı anda işlendiğini</strong> görebiliriz👀</p><h4>Sonuç olarak,</h4><p>Asenkron programlama, özellikle <strong>ağ istekleri, veri tabanı işlemleri ve büyük veri işlemleri</strong> için olmazsa olmaz olarak karşımıza çıkıyor.</p><h4>Özetle:</h4><p>✅ <strong>JavaScript’te</strong> setTimeout, Promise, async-await kullanılır.<br>✅ <strong>Python&#39;da</strong> asyncio ile asenkron işlemler yönetilir.</p><p>📈 <strong>Kodları hızlandırmak</strong> ve <strong>UI’yi bloklamamak</strong> için asenkron programlama hayat kurtarıcı olarak karşımıza çıkıyor.</p><blockquote>Teşekkürler! 🎉</blockquote><blockquote>Bu yazıda asenkron programlamanın ne olduğunu ve JavaScript ile Python’da nasıl kullanıldığını birlikte keşfettik. Umarım faydalı bir yazı olmuştur. Asenkron programlama, performans odaklı yazılım geliştirme sürecinde büyük bir fark yaratır.</blockquote><blockquote>Eğer yazıyla ilgili düşüncelerinizi paylaşmak veya aklınıza takılan bir soruyu sormak isterseniz, yorumlarda buluşalım! Daha fazla içerik için takipte kalın, bir sonraki yazımızda görüşmek üzere. 🚀</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2eff39f85370" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Interface, Polymorphism ve Inheritance Kavramları]]></title>
            <link>https://medium.com/@turguterkan55/interface-polymorphism-ve-inheritance-kavramlar%C4%B1-f1cb7c83d034?source=rss-f138beb1eefb------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1cb7c83d034</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[inheritance]]></category>
            <category><![CDATA[polymorphism]]></category>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Erkan TURGUT]]></dc:creator>
            <pubDate>Sun, 02 Jun 2024 19:31:33 GMT</pubDate>
            <atom:updated>2024-06-02T19:33:14.511Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hOoihNs83GBXxY9uEB7zVw.png" /></figure><p>Yazılım geliştirme dünyasında <strong>Interface</strong>, <strong>Polymorphism </strong>ve <strong>Inheritance </strong>gibi kavramlar, kodunuzu <em>daha esnek</em>, <em>modüler</em> ve <em>yeniden kullanılabilir </em>hale getirmek için <strong><em>kritik öneme</em></strong> sahiptir. Ancak, bu kavramları tam olarak anlamak ve projelerimizde etkin bir şekilde uygulamak bazen zorlayıcı olabilir. Bu yazıda, bu üç önemli kavramı C# dili ile anlaşılır örneklerle ele alacağız.</p><blockquote><strong>Katkı sağlaması dileğiyle, keyifli okumalar.</strong></blockquote><h3><strong>Interface (Arayüz)</strong></h3><p><strong><em>Nedir ?</em></strong></p><p>Interface, kısaca bir sınıfın hangi metotları içereceğini tanımlayan bir yapıdır, ancak bu metotların <strong><em>nasıl uygulanacağını belirtmez</em></strong>. Interface’ler, belirli bir davranışı paylaşan farklı sınıfların <em>aynı metodları içermesini</em> sağlar</p><p><strong><em>Ne için kullanılır?</em></strong></p><p>Interface, farklı sınıfların ortak bir davranışı paylaşmasını sağlamak için kullanılır. Bu, kodun <strong>daha esnek</strong> ve<strong> yeniden kullanılabilir </strong>olmasını sağlar.</p><blockquote>ÖRNEK:</blockquote><pre>public interface IAnimal<br>{<br> void MakeSound(); //sınıfların içermesi gereken metot.<br>}<br><br>public class Dog : IAnimal<br>{<br> public void MakeSound()<br> {<br> Console.WriteLine(&quot;Woof!&quot;);<br> }<br>}<br><br>public class Cat : IAnimal<br>{<br> public void MakeSound()<br> {<br> Console.WriteLine(&quot;Meow!&quot;);<br> }<br>}<br><br>public class Program<br>{<br> public static void Main()<br> {<br><br> IAnimal myDog = new Dog();<br> IAnimal myCat = new Cat();<br> myDog.MakeSound(); // Output(çıktı): Woof!<br> myCat.MakeSound(); // Output(çıktı): Meow!<br><br> }<br>}</pre><p>Bu örnekte, <strong><em>IAnimal arayüzü</em></strong>, <strong>Dog</strong> ve <strong>Cat </strong>sınıflarının <strong><em>MakeSound()</em></strong> metodunu <strong><em>içermesini garanti</em></strong> eder. Bu sayede farklı hayvan türleri, kendi seslerini çıkarabilir</p><h3>Polymorphism (Çok Biçimlilik)</h3><p><strong><em>Nedir ?</em></strong></p><p><strong>Polymorphism</strong>, bir nesnenin <em>farklı şekillerde</em> davranabilme yeteneğidir. Genellikle, bir sınıfın alt sınıflarının farklı şekillerde davranabilmesini sağlar.</p><p><strong><em>Ne için kullanılır?</em></strong></p><p>Polymorphism, <em>aynı metodun farklı sınıflarda farklı davranışlar</em> sergilemesini sağlar. Bu, kodun daha dinamik ve esnek olmasını sağlar</p><blockquote>ÖRNEK:</blockquote><pre>public class Animal<br>{<br><br> public virtual void MakeSound()<br> {<br> Console.WriteLine(&quot;Some sound&quot;); //MakeSound() metoduna ait içerik.<br> }<br><br>}<br><br>public class Dog : Animal<br>{<br><br> public override void MakeSound() // Override ile MakeSound() metodunun içeriğini ezip bu metoda kendi özellğimizi (Woof) verdik.<br> {<br> Console.WriteLine(&quot;Woof!&quot;);<br> }<br><br>}<br><br>public class Cat : Animal<br>{<br><br> public override void MakeSound()<br> {<br> Console.WriteLine(&quot;Meow!&quot;); // Override ile MakeSound() metodunun içeriğini ezip bu metoda kendi özellğimizi (Meow) verdik.<br> {<br> }<br><br>}<br><br><br>public class Program<br>{<br><br> public static void Main()<br> {<br><br> Animal myDog = new Dog(); <br> Animal myCat = new Cat();<br> myDog.MakeSound(); // Output(çıktı): Woof!<br> myCat.MakeSound(); // Output(çıktı): Meow!<br><br> }<br><br>}</pre><p>Bu örnekte,<strong><em> MakeSound() </em></strong>metodu <strong>Animal </strong>sınıfında tanımlanmış, ancak alt sınıflarda (<strong><em>Dog, Cat</em></strong>) farklı davranışlar sergilemiştir. Bu sayede, Animal tipi bir değişken<em> farklı hayvan sınıflarına ait nesneleri tutabilir</em> ve uygun metodu çağırabilir.</p><h3>Inheritance (Kalıtım)</h3><p><strong><em>Nedir ?</em></strong></p><p>Inheritance, bir sınıfın başka bir sınıfın özelliklerini ve metotlarını <em>devralmasını(</em><strong><em>miras almasını</em></strong><em>) </em>sağlar. Üst sınıf (base class) ile alt sınıf (derived class) arasında bir <strong><em>ilişki </em></strong>kurulur</p><p><strong><em>Ne için kullanılır?</em></strong></p><p><strong>Kalıtım</strong>, kod tekrarını azaltmak ve benzer sınıfları organize etmek için kullanılır. Alt sınıf, üst sınıfın özelliklerini ve metotlarını miras alır, bu da kodun <strong><em>daha temiz ve bakımı kolay</em></strong> olmasını sağlar.</p><blockquote>ÖRNEK:</blockquote><pre><br>public class Animal<br>{<br>    // Name isimli bir özellik (property) tanımlıyoruz. Bu özellik, hayvanın ismini tutacak.<br>    public string Name { get; set; }<br><br>    <br>    public void Eat() // Eat metodu Bu metod, hayvanın yeme eylemini simüle edecek.<br>    {<br>        <br>        Console.WriteLine($&quot;{Name} is eating.&quot;);<br>    }<br>}<br><br><br>public class Dog : Animal // Animal sınıfından kalıtım (inheritance) alan Dog sınıfını tanımlıyoruz.<br>{<br>    public void Bark()// DOG classınn kendi Bark metodu. Bu metod, köpeğin havlama eylemini simüle edecek.<br>    {<br>        <br>        Console.WriteLine(&quot;Woof!&quot;);<br>    }<br>}<br><br><br>public class Program<br>{<br>    <br>    public static void Main()<br>    {<br>        // Dog sınıfından bir nesne (instance) oluşturuyoruz.<br>        Dog myDog = new Dog();<br>        <br>        // myDog nesnesinin Name özelliğine &quot;Buddy&quot; değerini atıyoruz.<br>        myDog.Name = &quot;Buddy&quot;;<br>        <br>        // myDog nesnesinin Eat metodunu çağırıyoruz.<br>        // Bu metod, &quot;Buddy is eating.&quot; mesajını ekrana yazdıracak.<br>        myDog.Eat();<br>        <br>        // myDog nesnesinin Bark metodunu çağırıyoruz.<br>        // Bu metod, &quot;Woof!&quot; mesajını ekrana yazdıracak.<br>        myDog.Bark();<br>    }<br>}</pre><p>Bu örnekte, <strong><em>Dog </em></strong>sınıfı <strong>Animal </strong>sınıfını miras almış ve <em>Eat()</em> metodunu kullanabilir hale gelmiştir. Böylece <strong>Dog</strong> sınıfı, <em>hem </em><strong><em>Animal </em></strong><em>sınıfının özelliklerini hem de kendi özelliklerini taşır</em>.</p><h4><strong>Kısacası,</strong></h4><p><strong>Interface: </strong>Ne yapılacağını tanımlar ama nasıl yapılacağını belirtmez.<br><strong>Polymorphism:</strong> Aynı metodun farklı şekillerde davranmasını sağlar.<br><strong>Inheritance:</strong> Bir sınıfın başka bir sınıfın özelliklerini ve metotlarını miras almasını sağlar.</p><blockquote><strong><em>ÖZETLE:</em></strong></blockquote><p><strong>Interface</strong>, <strong>Polymorphism</strong> ve Inheritance, yazılım geliştirmede kodunuzu <em>daha esnek, modüler ve yeniden kullanılabilir</em> hale getiren önemli kavramlardır. C# dili ile anlattığım bu kavramları anlamak ve uygulamak, projelerinizde daha sağlam ve bakımı kolay kodlar yazmanızı sağlayacaktır.</p><p>Umarım bu yazı, bu kavramları daha iyi anlamanıza ve projelerinizde etkin bir şekilde kullanmanıza yardımcı olur. Eğer sorularınız veya eklemek istedikleriniz varsa, yorumlarda paylaşmaktan çekinmeyin.</p><p><strong><em>Bir sonraki yazıda görüşmek üzere, sağlıcakla kalın.</em></strong></p><p>Linkedin : <a href="https://www.linkedin.com/in/erkanturgut070322">Erkan TURGUT</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1cb7c83d034" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID Prensiplerini C# ile Anlamak: Temelden Uygulamaya Adım Adım Rehber]]></title>
            <link>https://medium.com/@turguterkan55/solid-prensiplerini-c-ile-anlamak-temelden-uygulamaya-ad%C4%B1m-ad%C4%B1m-rehber-a02d256a639b?source=rss-f138beb1eefb------2</link>
            <guid isPermaLink="false">https://medium.com/p/a02d256a639b</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Erkan TURGUT]]></dc:creator>
            <pubDate>Wed, 06 Mar 2024 13:06:32 GMT</pubDate>
            <atom:updated>2024-06-02T18:33:29.375Z</atom:updated>
            <content:encoded><![CDATA[<p>Yazılım geliştirme yolculuğuna yeni başlayanlar için SOLID prensipleri kafa karıştırıcı olabilir. Ancak, bu prensipler, kodumuzu daha okunabilir, sürdürülebilir ve esnek hale getirmemize yardımcı olabilir. Bu yazıda, SOLID prensiplerini daha basit bir dille açıklayarak, C# dilindeki temel örneklerle birlikte sunacağım. <strong><em>Single Responsibility,</em></strong> <strong><em>Open/Closed</em></strong>, <strong><em>Liskov Substitution</em></strong>, <strong><em>Interface Segregation</em></strong> ve <strong><em>Dependency Injection</em></strong> prensiplerini tek tek inceleyeceğiz. Hazırsanız, SOLID prensiplerine birlikte göz atalım ve daha iyi bir yazılım geliştirici olmak için adımlar atmaya başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_zq_Hrd7khm_yN14Z5bb9Q.png" /><figcaption>SOLID</figcaption></figure><h3>Single Responsibility Principle (Tek Sorumluluk Prensibi)</h3><p>Bu prensibe göre, bir sınıfın <em>sadece bir işi </em>olmalıdır. Yani, bir sınıfın tek bir amaç için değişmesi gerekmelidir. <strong>Örneğin,</strong> bir Araba sınıfı sadece arabanın özelliklerini ve davranışlarını içermelidir, başka bir işlevi olmamalıdır.</p><pre>public class Araba<br>{<br>    public void Calistir()<br>    {<br>        // Araba çalıştırma işlemleri<br>    }<br><br>    public void Dur()<br>    {<br>        // Arabayı durdurma işlemleri<br>    }<br><br>    public void GazVer()<br>    {<br>        // Gaz verme işlemleri<br>    }<br><br>    // Başka işlevler burada olmamalı<br>}</pre><h3>Open/Closed Principle (Açık/Kapalı Prensibi)</h3><p>Bu prensibe göre, bir sınıfın uzantılara kapalı (<em>değiştirilemez</em>) ancak <strong><em>değişikliklere açık</em></strong> (genişletilebilir) olması gerekmektedir. Yani, mevcut kodu değiştirmeden yeni işlevler ekleyebilmelisiniz.</p><pre>// Örnek: Şekil sınıfı<br>public abstract class Sekil<br>{<br>    public abstract double AlanHesapla();<br>}<br><br>// Örnek: Dikdörtgen sınıfı<br>public class Dikdortgen : Sekil<br>{<br>    public double Yukseklik { get; set; }<br>    public double Genislik { get; set; }<br><br>    public override double AlanHesapla()<br>    {<br>        return Yukseklik * Genislik;<br>    }<br>}<br><br>// Örnek: Kare sınıfı<br>public class Kare : Sekil<br>{<br>    public double KenarUzunlugu { get; set; }<br><br>    public override double AlanHesapla()<br>    {<br>        return KenarUzunlugu * KenarUzunlugu;<br>    }<br>}</pre><h3>Liskov Substitution Principle (Liskov Yerine Geçme Prensibi)</h3><p>Bu prensibe göre, bir üst sınıfın alt sınıfları, üst sınıfın<strong> yerine</strong> geçebilmelidir. Yani, alt sınıflar, üst sınıfın davranışlarını değiştirmeden kullanabilmelidir.</p><pre>// Örnek: Kuş sınıfı<br>public class Kus<br>{<br>    public virtual void Uc()<br>    {<br>        Console.WriteLine(&quot;Kuş uçuyor.&quot;);<br>    }<br>}<br><br>// Örnek: Penguen sınıfı<br>public class Penguen : Kus<br>{<br>    public override void Uc()<br>    {<br>        // Penguenler uçamaz, bu nedenle bu metot boş olabilir veya farklı bir davranış sergileyebilir.<br>        Console.WriteLine(&quot;Penguen uçamaz.&quot;);<br>    }<br>}</pre><h3>Interface Segregation Principle (Arayüz Ayrımı Prensibi)</h3><p>Bu prensibe göre, mümkünse, bir arayüz, onu kullanan sınıfların ihtiyaçlarına göre daha küçük ve özelleştirilmiş olmalıdır. Yani diyelim ki elimizde farklı farklı nesneler var fakat bu nesnelerin en az bir ortak işlevi var, bunlar için oluşturduğumuz interface’i hepsine implemente ettiğimizde bir nesne için geçerli olan durum diğer bir nesne için geçerli olmayabilir. İşte bu gibi durumlarda ‘’<em>Interface Segregation Principle’’ </em>prensibini uygulayıp bu nesnelere ayrı ayrı implemente etmek üzere farklı arayüz (interface) üretimi yaparız. Bu sayede tek bir nesneye birden fazla interface’i implemente edebiliriz. Haydi gelin aşağıda bir örnekle bunu pratiğe dökelim.</p><pre>// Örnek: Arayüzlerin ayrılması<br>public interface ISesCikarabilir<br>{<br>    void SesCikar();<br>}<br><br>public interface ITirmanabilir<br>{<br>    void Tirman();<br>}<br><br>// Örnek: Kedi sınıfı( kedi hem ses çıkarıp hem tırmanabiliyor) <br>public class Kedi: ISesCikarabilir, ITirmanabilir<br>{<br>    public void SesCikar()<br>    {<br>        Console.WriteLine(&quot;Miyav !&quot;);<br>    }<br><br>    public void Tirman()<br>    {<br>        Console.WriteLine(&quot;Kedi tirmanıyor.&quot;);<br>    }<br>}<br><br>// Örnek: Köpek sınıfı<br>public class Köpek: ISesCikarabilir<br>{<br>    public void SesCikar()<br>    {<br>        Console.WriteLine(&quot;Hav hav!&quot;);<br>    }<br>}<br></pre><h3>Dependency Inversion Principle (Bağımlılık Tersine Çevirme Prensibi)</h3><p><strong>‘’Dependency Inversion Principle’’ </strong>prensibine göre, yüksek seviyeli sınıflar, düşük seviyeli sınıflara bağımlı <strong><em>olmamalıdır. </em></strong>Bunun yerine, her iki tür de soyutlamalara (arayüzlere) bağımlı olmalıdır. Bu, bağımlılıkların daha esnek, değiştirilebilir ve test edilebilir olmasını sağlar.</p><pre>//Öncelikle, ILogger arayüzünü tanımlıyoruz. Bu arayüz, loglama işlevselliğini temsil eder.<br>public interface ILogger<br>{<br>    void Log(string mesaj);<br>}<br><br>//Ardından, ILogger arayüzünü uygulayan iki farklı <br>//düşük seviyeli sınıf oluşturuyoruz: DosyaLogger ve VeritabaniLogger.<br><br>// Örnek: DosyaLogger sınıfı<br>public class DosyaLogger : ILogger // ILogger tarafından İmplemente edilimiş sınıf<br>{<br>    public void Log(string mesaj)<br>    {<br>        // Mesajı dosyaya kaydet<br>    }<br>}<br><br>// Örnek: VeritabaniLogger sınıfı<br>public class VeritabaniLogger : ILogger<br>{<br>    public void Log(string mesaj)<br>    {<br>        // Mesajı veritabanına kaydet<br>    }<br>}<br><br>//Son olarak, yüksek seviyeli bir sınıf olan VeriIsleme sınıfını oluşturuyoruz.<br>// Bu sınıf, ILogger arayüzüne (bağımlı) olacak şekilde tasarlanmıştır.<br><br><br>// Örnek: VeriIsleme sınıfı<br>public class VeriIsleme<br>{<br>    private readonly ILogger _logger;<br><br>    public VeriIsleme(ILogger logger) // ILogger&#39;ı parametre olarak verdik.<br>    {<br>        _logger = logger;<br>    }<br><br>    public void VeriIsle()<br>    {<br>        // Veri işleme işlemleri...<br>        _logger.Log(&quot;Veri işlendi.&quot;);<br>    }<br>}</pre><blockquote>Bu örneklerin, SOLID prensiplerini daha basit bir dilde anlamanıza yardımcı olacağını umuyorum. Bu prensipleri öğrenirken, her birinin yazılım geliştirmeye nasıl katkı sağladığını anlamak ve araştırmak bizler için çok önemli bir yer tutar.</blockquote><p>Bu yazıda, SOLID prensiplerini anlatırken C# dilinde basit örneklerle birlikte inceledik. <strong><em>Single Responsibility</em></strong> ile her sınıfın sadece bir sorumluluğa sahip olması gerektiğini, <strong><em>Open/Closed</em></strong> ile kodun değişime kapalı ancak genişlemeye açık olması gerektiğini, <strong><em>Liskov Substitution</em></strong> ile alt sınıfların üst sınıfların yerine geçebilmesi gerektiğini, <strong><em>Interface Segregation </em></strong>ile geniş arayüzler yerine özel arayüzlerin kullanılması gerektiğini ve <strong><em>Dependency Injection </em></strong>ile bağımlılıkların dışarıdan enjekte edilmesi gerektiğini öğrendik. Bu prensipleri uygulayarak, daha temiz, esnek ve sürdürülebilir kodlar yazabilir ve daha iyi bir yazılım geliştirici olabilirsiniz. Yolculuğunuzda başarılar diler, okuduğunuz için teşekkür ederim. Sağlıcakla kalın ⭐. Görüşmek üzere…</p><p>Bana ulaşmak için: <a href="http://www.linkedin.com/in/erkanturgut070322">Linkedin</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a02d256a639b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>