<?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 HSD İnönü Üniversitesi on Medium]]></title>
        <description><![CDATA[Stories by HSD İnönü Üniversitesi on Medium]]></description>
        <link>https://medium.com/@hsdinonu?source=rss-faf29e12ba4c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WTJIrSuXALDTntz5nPGLKg.png</url>
            <title>Stories by HSD İnönü Üniversitesi on Medium</title>
            <link>https://medium.com/@hsdinonu?source=rss-faf29e12ba4c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:35:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hsdinonu/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[Dijital Dünyada Verilerimiz Nasıl Saklanıyor?]]></title>
            <link>https://medium.com/huawei-student-developers-turkiye/dijital-d%C3%BCnyada-verilerimiz-nas%C4%B1l-saklan%C4%B1yor-4b5124448848?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b5124448848</guid>
            <category><![CDATA[data]]></category>
            <category><![CDATA[data-center]]></category>
            <category><![CDATA[kuvars-cam]]></category>
            <category><![CDATA[dna]]></category>
            <category><![CDATA[cloud-storage]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Fri, 22 May 2026 18:52:58 GMT</pubDate>
            <atom:updated>2026-05-22T18:52:58.051Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H1Gsq8t1RnSbXbxNVUfEsg.png" /><figcaption><a href="https://gemini.google.com/app">Görsel 1: Dijital Dünyada Verilerimiz</a></figcaption></figure><h4>Giriş</h4><p>Günümüzde saniyeler içerisinde milyonlarca veri üretiliyor ve tüketiliyor; elbette bu kadar devasa miktarda verinin bir şekilde saklanması gerekiyor.</p><p>Bu yazımızda, verilerin temel saklanma biçimi olan 0 ve 1&#39;lerden, devasa miktarlarda HDD/SDD‘lerden oluşan veri merkezleri (<strong>Data Center)</strong> ve geleceğin depolama teknolojisi olan<strong> kuvars cam </strong>ve <strong>DNA </strong>belleklere kadar verinin yolculuğunu ele alacağız.</p><h4>Fiziksel Temel : 0 ve 1</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*-S8wob663SWg4LEYgy9wZA.png" /><figcaption><a href="https://medium.com/@hiakboga/bilgisayar%C4%B1n-temeli-0-ve-1-ce7dfffed3cb">Görsel 2: Bilgisayarların Dili: 0 ve 1</a></figcaption></figure><p>Dijital dünyada her şey ikilik sistem (binary) üzerine kuruludur. Bir fotoğraf ya da bir video da tamamen bir dizi 0 ve 1’den oluşur. Kısacası dijital dünyada her şeyin bir 0 ve 1 karşılığı bulunmaktadır. Örneğin; alfabedeki tek bir harf, sekiz tane 0 ve 1’in yan yana gelmesiyle oluşan 1 Baytlık (Byte) veri birimi ile temsil edilir. Alfabedeki “a” karakterinin karşılığı “<strong>01100001</strong>”dir.</p><p>Ancak bu soyut rakam dizilerinin kalıcı olabilmesi için fiziksel bir zemine mühürlenmeleri gerekir. Bu noktada, teknolojinin gelişmesiyle birlikte birçok kalıcı depolama yöntemi ortaya çıkmıştır. Bunlar:</p><p><strong>1 — Sabit Disk Sürücüleri (HDD)<br></strong>Geleneksel sabit disklerde veriler, hızla dönen metal plakalar üzerindeki mikroskobik mıknatıs alanları olarak saklanır. Bir alanın kuzey kutbu yukarı bakıyorsa <strong>“1”</strong>, aşağı bakıyorsa <strong>“0”</strong> demektir.</p><p><strong>2 — Katı Hal Sürücüsü (SSD) ve Flash Bellekler<br></strong>Modern cihazlarda artık HDD’ler yerine SSD’ler kullanılmaktadır. Veriler, <strong>“yüzer kapılı transistör” </strong>adı verilen hücrelerin içine hapsedilen elektronlar sayesinde saklanır. Hücrede elektrik yükü varsa bu “1”, yoksa “0” anlamına gelmektedir.</p><p><strong>3 — Kompakt Diskler (CD)<br></strong>Günümüzde pek fazla kullanılmasa da verinin fiziksel olarak depolanmasının en temel örneklerindendir. Bu disklerde veriler, lazerin okuyabileceği mikroskobik çukurlar ve düzlükler olarak saklanırdı.</p><h4>Bulut Teknolojisi: Cloud Storage (Bulut Depolama)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*5Hk1PVG-UBsj-5oUHpUA7Q.jpeg" /><figcaption><a href="https://bulutistan.com/blog/bulut-teknolojisi-nedir/">Görsel 3: Bulut Depolama ve Teknolojisi</a></figcaption></figure><p>Bulut depolama; verilerimizi bilgisayar veya harici bellek yerine, dev veri merkezlerindeki binlerce güçlü sunucuda barındırır. Bu teknoloji sayesinde dosyalarımızı hem güvenle saklar hem de dilediğimiz yerden kolayca erişip paylaşabiliriz.</p><p><strong>Bulut Depolama (Cloud Storage) Nasıl Çalışır?</strong></p><p>Dijital dünyada her gün devasa miktarda fotoğraf, video ve belge üretiyoruz. Tüm bu verileri telefon veya bilgisayar hafızasında saklamak artık neredeyse imkânsız. İşte bu noktada devreye giren bulut depolama, verilerimizi hem güvenle saklıyor hem de her cihazdan erişilebilir kılıyor. Peki, bu sistem perde arkasında nasıl çalışıyor?</p><ol><li><strong>Veri Yükleme: </strong>Fotoğraf, video veya belgeler cihazınızdan internet aracılığıyla buluta yüklenmektedir.</li><li><strong>Güvenli Şifreleme: </strong>Veriler güçlü algoritmalar ile şifrelenmektedir.</li><li><strong>Sunucularda Saklama: </strong>Veriler, farklı şehir veya ülkelerde bulunan <strong>veri merkezlerinde</strong> tutulmaktadır.</li><li><strong>Yetkilendirilmiş Erişim: </strong>Kullanıcı adı, şifre ve ek güvenlik doğrulamalarıyla erişim sağlanmaktadır.</li><li><strong>Esnek Kapasite:</strong> Veri miktarı arttıkça kapasite otomatik olarak büyütülmektedir.</li><li><strong>Kullandıkça Öde Modeli: </strong>Kullanıcılar sadece ihtiyaç duyulan depolama alanı için ücret ödemektedir.</li></ol><h4>Geleceğin Teknolojileri : Kuvars Cam ve DNA Bellekler</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C6OUvFPoXl-kD-T4mTo9Zg.png" /><figcaption><a href="https://www.technopat.net/2025/12/15/tek-bir-diskte-360-tb-veri-depolamak-mumkun-olacak/">Görsel 4: Kuvars Cam ve DNA Bellekler</a></figcaption></figure><p>Günümüzde yaygın olarak SDD/HDD ‘ler kullanılmaktadır, ancak bu depolama birimleri gerek depolama kapasitesi gerekse hız ve verim anlamında yetersiz kalmaktadır.</p><blockquote><em>SPhotonix’in 5D cam bellek teknolojisi, tek bir cam diskte 360 TB veri ve evren yaşı kadar dayanıklılık vadediyor. Veri merkezleri için ne anlama geliyor?</em></blockquote><p>5D cam bellek, veri saklama dünyasında yeni bir çığır açmaktadır. Sistemin kalbinde <strong>füzyon silika (kuvars)</strong> camdan üretilmiş 5 inçlik bir disk bulunuyor. Veri, femtosaniye lazerle oluşturulan nanoskopik yapılar sayesinde yazılıyor. Bu yapıların yalnızca konumu değil, yönü ve yoğunluğu da bilgi taşıyor. Böylece klasik üç boyutun ötesine geçiliyor. Sonuç olarak tek bir cam disk içinde <strong>360 TB’</strong>a kadar veri saklanabiliyor. Verinin uygun koşullarda <strong>13,8 milyar</strong> yıl boyunca bozulmadan saklanabileceği öngörülmektedir.</p><p>Geleneksel sabit diskler veya SSD’ler veriyi ikili (binary) sistemde saklarken,<strong> DNA </strong>tabanlı depolama dörtlü bir sistem kullanır. Klasik bilgisayarlardaki 0 ve 1&#39;ler yerine; DNA’nın dört temel yapı taşı olan <strong>Adenin (A)</strong>, <strong>Timin (T)</strong>, <strong>Guanin (G)</strong> ve <strong>Sitozin (C) </strong>bazları kullanılarak devasa miktardaki veriler depolanabilir.</p><p>Geleneksel bilgisayarlarda her şeyin bir<strong> 0–1</strong> karşılığı bulunmaktadır. Burada da bu bazların karşılıkları şöyledir:</p><ul><li><strong>Adenin (A): </strong>00</li><li><strong>Sitozin (C): </strong>01</li><li><strong>Guanin (G): </strong>10</li><li><strong>Timin (T): </strong>11</li></ul><p>Böylece 1 gram sentetik DNA içine <strong>215 petabayt </strong>veri depolanabiliyor. Ancak hem cam belleklerin hem de DNA belleklerin ortak sorunu, veri yazma ve okuma hızlarının düşük olmasıdır. Gelecekte bu sorunların aşılması halinde teknolojide ciddi bir çığır açılacaktır.</p><h4>Sonuç</h4><p>Dijital dünya, her ne kadar dokunulmaz ve soyut görünse de, aslında fiziksel bir gerçekliğin üzerine inşa edilmiştir. Attığımız her adım, bir yerlerdeki manyetik disklerde ya da mikroçiplerde <strong>0 ve 1</strong> olarak karşılık buluyor. Bugün devasa veri merkezlerinde sakladığımız bu yığınlar, yarın <strong>DNA sarmallarında</strong> veya <strong>kuvars camlarda</strong> binlerce yıl bozulmadan kalabilecek.</p><p>Teknoloji ne kadar gelişirse gelişsin, verilerimizi saklama arayışımız aslında tek bir amaca hizmet ediyor: Bilgiyi ölümsüzleştirmek. Belki de gelecekte, bugün “bulut” dediğimiz o devasa yapılar, bir avucumuza sığacak kadar küçülecek; ancak temelindeki o basit <strong>“varlık ve yokluk”</strong> (0 ve 1) felsefesi değişmeden kalacak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZp01YT35TSXf6Tvk1ibOg.png" /></figure><h4>Referanslar</h4><ul><li><a href="https://www.turkcell.com.tr/blog/dijital-hafizanin-yeni-evi-bulut-depolama?source=post_page-----8d34f783613f---------------------------------------">Bulut Depolama (Cloud Storage) Nedir? Nasıl Çalışır? - Turkcell Blog</a></li><li><a href="https://www.technopat.net/2025/12/15/tek-bir-diskte-360-tb-veri-depolamak-mumkun-olacak/?source=post_page-----8d34f783613f---------------------------------------">Tek bir diskte 360 TB veri depolamak mümkün olacak - Technopat</a></li><li><a href="https://akillitasarim.wordpress.com/2013/02/02/organik-bilgisayarlara-dna-veri-depolama/?source=post_page-----8d34f783613f---------------------------------------">ORGANİK BİLGİSAYARLARA (DNA) VERİ DEPOLAMA</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b5124448848" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-student-developers-turkiye/dijital-d%C3%BCnyada-verilerimiz-nas%C4%B1l-saklan%C4%B1yor-4b5124448848">Dijital Dünyada Verilerimiz Nasıl Saklanıyor?</a> was originally published in <a href="https://medium.com/huawei-student-developers-turkiye">HUAWEI Student Developers Turkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[İnsanlığın Yeni Gözleri: Algoritmalar Evreni Nasıl Okuyor?]]></title>
            <link>https://medium.com/huawei-student-developers-turkiye/i%CC%87nsanl%C4%B1%C4%9F%C4%B1n-yeni-g%C3%B6zleri-algoritmalar-evreni-nas%C4%B1l-okuyor-12f525ec1022?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/12f525ec1022</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[cnn]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[image-processing]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Fri, 01 May 2026 10:19:42 GMT</pubDate>
            <atom:updated>2026-05-01T10:19:42.851Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*UhrAi0hpXjL3x5P2ORp_xA.png" /><figcaption><a href="https://science.nasa.gov/wp-content/uploads/2023/11/nasa-moon-10x10-poster-front.jpg">Görsel 1: Uzay Keşfi ve Astronot Perspektifi</a></figcaption></figure><h3>Giriş</h3><p>Bir gün gökyüzüne baktığınızda aslında baktığınız şeyin<strong> <em>sadece bir görüntü olmadığını</em></strong> düşünün.</p><p>Çok uzaklarda bir yıldızın ışığında milisaniyelik bir değişim oluyor olabilir. Bu değişim, başka bir gezegenin varlığına işaret edebilir. Ama insan gözü bunu fark edemez. Fakat bir algoritma fark edebilir.</p><p>Bugünlerde uzayı keşfetme şeklimiz gitgide değişiyor. Teleskoplar ve uydular veri toplarken, asıl anlamı üreten şey yazılım sistemleri oluyor.</p><h3>1. Uzayın gözleri: Uydular</h3><p>Dünya’yı ve evreni gözlemleyen uydular artık sadece fotoğraf çeken cihazlar değil. Onlar:</p><ul><li>Farklı spektral bantlardan veri toplar.</li><li>Görünür ışığın ötesinde kızılötesi gibi bantları analiz eder.</li><li>Gezegeni sürekli gözlemler.</li></ul><p>Ama burada önemli bir gerçek var: Bu veriler “görüntü” gibi görünse de aslında sürekli devam eden bir <strong><em>veri akışıdır</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*6QaEATEts9gLFD03GZSkUA.png" /><figcaption><a href="https://ioturkiye.com/2024/08/iotnin-evrimi-uydu-teknolojisi-ile-kuresel-kapsama-alani/">Görsel 2: Uzaktan algılama ve uydu veri akışının temsili</a></figcaption></figure><h3>2. Asıl problem: Fazla veri</h3><p>Uydu sistemleri saniyeler içinde:</p><ul><li>Milyonlarca piksel üretir.</li><li>Sürekli veri akışı oluşturur.</li><li>İnsanın doğrudan anlayamayacağı boyutta bilgi taşır.</li></ul><p>Burada kritik nokta şudur: <strong>Veri var ama anlam yoktur. </strong>Anlam, ancak bu verinin işlenmesiyle ortaya çıkar.</p><h3>3. Görüntü işleme: Evreni okunabilir hale getirmek</h3><p>Ham uydu görüntüleri doğrudan kullanılmaz. Süreç genelde şu şekilde işler:</p><ul><li>Gürültü azaltma</li><li>Normalizasyon</li><li>Özellik çıkarımı</li><li>Segmentasyon</li><li>Anomali tespiti</li></ul><p>Bu adımlar tamamlandığında görüntü artık sadece piksel değildir. <strong>Yorumlanabilir bilgiye dönüşür.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*KX0ymxfMSniJTf4e3Tdhyg.png" /><figcaption><a href="https://www.simurgai.com/G%C3%B6r%C3%BCnt%C3%BC-%C4%B0%C5%9Fleme-Nedir/">Görsel 3: Görüntü işleme alanının temel bileşenleri ve disiplinler arası yapısı</a></figcaption></figure><h3>4. Algoritmaların keşif gücü</h3><p>Makine öğrenmesi modelleri burada kritik rol oynar.</p><p>Özellikle:</p><ul><li>CNN (Convolutional Neural Networks)</li><li>Zaman serisi analiz modelleri</li><li>Anomali tespit algoritmaları</li></ul><p>şu yetenekleri kazanır:</p><ul><li>Normal davranışları öğrenme</li><li>Küçük sapmaları fark etme</li><li>İnsan gözünün göremediği desenleri bulma</li></ul><p>Bu noktada sistem artık<em> sadece analiz yapmaz</em>. “<strong>Keşfetmeye başlar.”</strong></p><h3>5. Yapay zekânın uzaydaki rolü</h3><p>Bu dönüşüm sadece teorik değildir. Uluslararası Uzay İstasyonu’nda test edilen yapay zekâ destekli robotik sistemler:</p><ul><li>İnsan müdahalesi olmadan hareket edebiliyor.</li><li>Görevleri otonom şekilde yapabiliyor.</li><li>Rota planlamasını kendi optimize edebiliyor.</li></ul><p>Hatta bu sistemler planlama hızını ciddi şekilde artırabiliyor. Bu, yazılımın artık sadece “araç” değil, <strong>karar veren bir yapı</strong> haline geldiğini gösteriyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*MXnXuvJ1NPZ4L47LNPNrxQ.jpeg" /><figcaption><a href="https://www.bilimkurgukulubu.com/genel/inceleme/dunya-disi-yapay-zekaya-dair-spekulasyonlar/">Görsel 4: Yapay zekâ destekli otonom sistemlerin uzay keşfindeki rolü</a></figcaption></figure><h3>6. Paradigma değişimi</h3><p>Eskiden süreç şu şekildeydi:</p><p>İnsan → gözlem → analiz → karar</p><p>Şimdi ise:</p><p>Veri → algoritma → analiz → insan yorumu</p><p>Bu küçük bir değişim değil, keşif yönteminin tamamen değişmesi demek.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*k8UXa3oj7QhnArQe.jpg" /><figcaption><a href="https://www.presentationgo.com/presentation/ai-neural-network-brain/">Görsel 5: Verinin algoritmalar aracılığıyla anlamlı bilgiye dönüştürülmesi süreci</a></figcaption></figure><h3>7. Sonuç: Belki de ilk keşif bir algoritmadan gelecek</h3><p>Bir gün yeni bir gezegen keşfedildiğinde, bunu ilk fark eden bir insan olmayabilir.</p><p>O keşfi yapan şey:</p><ul><li>Bir teleskop değil</li><li>Bir gözlemci değil</li><li>Bir insan değil</li></ul><p><strong>bir algoritma olabilir. </strong>Ve belki de insanlık tarihinde ilk kez şu gerçek kabul edilecek:</p><blockquote>Evreni keşfetmeye başlayan şey gözlerimiz değil, yazdığımız kodlar olacak.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zP4_wjRVkBN2F9YW5Xsnrg.jpeg" /></figure><h4>REFERANSLAR</h4><ul><li><a href="https://sarkac.org/2020/10/uzaydaki-gozlerimiz-uydu-kameralari/">Uzaydaki gözlerimiz: Uydu kameraları - Sarkaç</a></li><li><a href="https://news.stanford.edu/stories/2025/12/ai-robot-international-space-station-autonomous-missions">AI advances robot navigation on the International Space Station</a></li><li><a href="https://link.springer.com/article/10.1007/s12665-025-12798-w">AI in remote sensing and satellite image processing-a review - Environmental Earth Sciences</a></li><li><a href="https://rutagon.com/insights/satellite-data-processing-ai/">Satellite Data Processing with AI: Technical Overview | Rutagon</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12f525ec1022" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-student-developers-turkiye/i%CC%87nsanl%C4%B1%C4%9F%C4%B1n-yeni-g%C3%B6zleri-algoritmalar-evreni-nas%C4%B1l-okuyor-12f525ec1022">İnsanlığın Yeni Gözleri: Algoritmalar Evreni Nasıl Okuyor?</a> was originally published in <a href="https://medium.com/huawei-student-developers-turkiye">HUAWEI Student Developers Turkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AOP Nedir? Spring Boot ile Cross-Cutting Concerns Yönetimi]]></title>
            <link>https://medium.com/huawei-student-developers-turkiye/aop-nedir-spring-boot-ile-cross-cutting-concerns-y%C3%B6netimi-e5e41f431448?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5e41f431448</guid>
            <category><![CDATA[spring-aop]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[cross-cutting-concerns]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 16:39:06 GMT</pubDate>
            <atom:updated>2026-04-24T16:39:06.569Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jbek_OjYOeZdIQzz5oxL0A.jpeg" /><figcaption><strong>Görsel 1: AOP ve Spring Boot</strong></figcaption></figure><h3>Giriş</h3><p>Günümüz modern backend uygulamalarında sadece iş mantığını doğru yazmak yeterli değildir. Uygulamanın sürdürülebilir, okunabilir ve yönetilebilir olması da en az bunun kadar önemlidir. Özellikle büyüyen projelerde <strong>loglama</strong>, <strong>güvenlik kontrolleri</strong>, <strong>transaction </strong>yönetimi ve <strong>performans ölçümü</strong> gibi işlemler, uygulamanın birçok farklı noktasına dağılmaya başlar. Bu durum zamanla kod tekrarına, karmaşıklığa ve bakım zorluklarına neden olur.</p><p>Bu noktada <strong>Aspect Oriented Programming (AOP)</strong> devreye girer. AOP, uygulama genelinde tekrar eden bu tür işlemleri merkezi bir noktadan yönetmeyi sağlayan bir yaklaşım sunar. Böylece iş mantığı ile ortak sorumluluklar birbirinden ayrılır ve daha temiz bir mimari elde edilir.</p><p>Bu yazıda, <strong>AOP</strong> kavramını ve <strong>cross-cutting concerns</strong> mantığını ele alacak, ardından Spring Boot ile bu yapının nasıl uygulanabileceğini pratik bir örnek üzerinden inceleyeceğiz.</p><h3>AOP Nedir?</h3><p>Aspect Oriented Programming (AOP), uygulama içerisinde farklı katmanlara yayılan ortak davranışları merkezi bir noktadan yönetmeyi amaçlayan bir programlama yaklaşımıdır. Geleneksel nesne yönelimli programlamada (OOP), bu tür davranışlar genellikle servis veya controller katmanlarına doğrudan eklenir. Ancak bu durum, zamanla kodun şişmesine ve iş mantığının gölgelenmesine neden olur.</p><p>AOP, bu problemi çözmek için iş mantığı ile bu ortak davranışları birbirinden ayırır. Böylece geliştiriciler sadece iş mantığına odaklanırken <strong>loglama</strong>, <strong>güvenlik </strong>veya <strong>performans </strong>gibi konular ayrı bir katmanda ele alınabilir. Bu yaklaşım, özellikle büyük ve karmaşık projelerde kodun daha modüler ve sürdürülebilir olmasını sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*d028mE1UHfRTz8jbuhwi4g.jpeg" /><figcaption><a href="https://aniday.com/en/blog/what-is-aop-aspect-oriented-programming-2618"><strong>Görsel 2: Aspect Oriented Programming (AOP) yapısının temel prensipleri</strong></a></figcaption></figure><h3>Cross-Cutting Concerns Nedir?</h3><p>Cross-cutting concerns, uygulamanın birçok farklı noktasını ilgilendiren ancak doğrudan iş mantığının bir parçası olmayan yapılardır. Bu tür sorumluluklar genellikle uygulamanın farklı katmanlarında tekrar eder ve zamanla kodun okunabilirliğini azaltır.</p><p>Örneğin bir serviste kullanıcı oluşturma işlemi yapılırken aynı zamanda <strong>loglama </strong>yapılması, yetkilendirme kontrolü gerçekleştirilmesi veya işlem süresinin ölçülmesi gerekebilir. Bu işlemler iş mantığının kendisi değildir ancak her yerde tekrar eder. İşte bu tekrar eden yapılar <strong>cross-cutting concerns</strong> olarak adlandırılır.</p><p>AOP sayesinde bu tür işlemler ana iş akışından ayrılarak merkezi bir şekilde yönetilebilir. Bu da hem kod tekrarını azaltır hem de uygulamanın genel yapısını daha temiz hale getirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*21f1bkwoetLlheE-.jpg" /><figcaption><a href="https://www.c-sharpcorner.com/UploadFile/vendettamit/managing-cross-cutting-concerns-the-logger-and-logging/"><strong>Görsel 3: Cross-Cutting Concerns’in katmanlar arası dağılımı ve aspect yaklaşımı</strong></a></figcaption></figure><h3>AOP Hangi Problemleri Çözer?</h3><p>AOP, özellikle uygulama genelinde tekrar eden ve farklı katmanlara yayılan problemlerin çözümünde oldukça etkilidir. Loglama işlemleri, bir uygulamada neredeyse her metotta ihtiyaç duyulan bir yapıdır. Aynı şekilde güvenlik kontrolleri, kullanıcı yetkilendirme süreçleri veya performans ölçümleri de uygulamanın birçok noktasında tekrar eder.</p><p>Bu tür işlemler klasik yöntemlerle her metota ayrı ayrı eklendiğinde kodun okunabilirliği azalır ve bakım maliyeti artar. AOP ise bu işlemleri merkezi bir noktadan yöneterek uygulamanın daha sade ve anlaşılır olmasını sağlar. Böylece geliştiriciler sadece iş mantığına odaklanabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/0*jeZBRcCMNBCG9BQb.gif" /><figcaption><a href="https://www.ercim.eu/publication/Ercim_News/enw58/mens.html"><strong>Görsel 4: AOP öncesi dağınık yapı ve AOP sonrası merkezi yönetilen yapı</strong></a></figcaption></figure><h3>Spring Boot ile AOP Kullanımı</h3><p>Spring Boot, AOP kullanımını oldukça kolaylaştıran hazır bir altyapı sunar. Gerekli bağımlılık eklendikten sonra, sadece bir sınıfı aspect olarak tanımlayarak uygulama genelinde davranış eklemek mümkündür. Bu yapı, Spring’in <strong>proxy </strong>mekanizması sayesinde çalışır ve belirlenen metotlar otomatik olarak yakalanarak ilgili işlemler uygulanır.</p><p>AOP kullanabilmek için öncelikle gerekli bağımlılığı projeye eklemek gerekir:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><p>Bu bağımlılık ile birlikte Spring Boot, AOP altyapısını otomatik olarak aktif hale getirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1lOHCH4hdhm3oDhf.png" /><figcaption><a href="https://anjireddy-kata.medium.com/java-101-mastering-spring-aop-aspect-oriented-programming-62bf994ca044"><strong>Görsel 5: Spring AOP’de kullanılan temel kavramlar, advice türleri ve pointcut ifadeleri</strong></a></figcaption></figure><h3>Logging Aspect Uygulaması</h3><p>AOP’nin en yaygın kullanım senaryolarından biri loglamadır. Bir uygulamada tüm servis metotlarının ne zaman çalıştığını ve ne kadar sürdüğünü merkezi olarak takip etmek isteyebiliriz. Bu işlemi her metota ayrı ayrı eklemek yerine, AOP ile tek bir noktadan çözebiliriz.</p><pre>@Aspect<br>@Component<br>@Slf4j<br>public class LoggingAspect {<br><br>    @Around(&quot;execution(* com.example.service.*.*(..))&quot;)<br>    public Object logMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {<br><br>        long start = System.currentTimeMillis();<br><br>        log.info(&quot;Metot başladı: {}&quot;,<br>                joinPoint.getSignature().toShortString());<br><br>        Object result = joinPoint.proceed();<br><br>        long duration = System.currentTimeMillis() - start;<br><br>        log.info(&quot;Metot bitti: {} | Süre: {} ms&quot;,<br>                joinPoint.getSignature().toShortString(),<br>                duration);<br><br>        return result;<br>    }<br>}</pre><p>Bu yapı sayesinde belirli bir paket altındaki tüm metotlar otomatik olarak yakalanır ve metot çalışmadan önce ve sonra loglama yapılır. Böylece herhangi bir servis metotuna müdahale etmeden, uygulama genelinde merkezi bir loglama mekanizması kurulmuş olur.</p><h3>AOP Kullanırken Dikkat Edilmesi Gerekenler</h3><p>AOP güçlü bir araç olmasına rağmen yanlış kullanıldığında karmaşıklığı artırabilir. Özellikle aşırı kullanım durumunda uygulamanın hangi noktada ne yaptığını anlamak zorlaşabilir. Debug süreci de klasik yapılara göre daha karmaşık hale gelebilir.</p><p>Bu nedenle AOP’nin sadece gerçekten gerekli olan cross-cutting problemler için kullanılması önemlidir. Aksi takdirde sağladığı avantajların yanında yeni problemler de ortaya çıkabilir.</p><h3>Sonuç</h3><p><strong>AOP</strong>, modern backend uygulamalarında tekrar eden işlemleri merkezi bir noktadan yönetmek için oldukça güçlü bir yaklaşım sunar. <strong>Cross-cutting concerns</strong> olarak adlandırılan yapıları iş mantığından ayırarak daha temiz daha okunabilir ve daha sürdürülebilir bir kod yapısı elde edilmesini sağlar.</p><p>Spring Boot ile birlikte AOP’nin uygulanması oldukça kolaydır ve doğru kullanıldığında uygulamanın mimarisine ciddi katkı sağlar. Özellikle loglama, güvenlik ve performans gibi konuların merkezi bir şekilde yönetilmesi, büyük projelerde önemli bir avantaj sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*AGPaVZyy2n3h06FZinYtGg.jpeg" /></figure><h3>Referanslar</h3><ul><li><a href="https://docs.spring.io/spring-framework/reference/core/aop.html">Aspect Oriented Programming with Spring</a></li><li><a href="https://www.baeldung.com/spring-aop">Introduction to Spring AOP | Baeldung</a></li><li><a href="https://www.digitalocean.com/community/tutorials/spring-aop-example-tutorial-aspect-advice-pointcut-joinpoint-annotations">Spring AOP Tutorial: Aspect, Advice, Pointcut Examples | DigitalOcean</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5e41f431448" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-student-developers-turkiye/aop-nedir-spring-boot-ile-cross-cutting-concerns-y%C3%B6netimi-e5e41f431448">AOP Nedir? Spring Boot ile Cross-Cutting Concerns Yönetimi</a> was originally published in <a href="https://medium.com/huawei-student-developers-turkiye">HUAWEI Student Developers Turkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JVM’de Garbage Collection Nasıl Çalışır? G1GC, ZGC ve Performans Pratikleri]]></title>
            <link>https://medium.com/huawei-student-developers-turkiye/jvmde-garbage-collection-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-g1gc-zgc-ve-performans-pratikleri-bba4db14f2fa?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/bba4db14f2fa</guid>
            <category><![CDATA[java-garbage-collection]]></category>
            <category><![CDATA[jvm-architecture]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[jvm]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 16:33:41 GMT</pubDate>
            <atom:updated>2026-03-31T16:33:41.596Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*woX44-hxmsoQyKGQOtMuAA.png" /><figcaption><a href="https://gemini.google.com/">Görsel Referansı</a></figcaption></figure><h4>Giriş</h4><p>Java uygulamalarında performans problemlerinin önemli bir kısmı “GC yüzünden yavaşlıyor” cümlesinden başlar. Ama GC’yi doğru yönetmek; <em>neyin</em> toplandığını, <em>ne zaman</em> duraklatma yaptığını, <em>hangi metriklerle</em> karar verdiğini ve <em>hangi ayarın</em> etkilediğini bilmekle mümkün olur. Bu yazıda JVM GC’nin temel işleyişini, sonra da pratikte en sık karşılaşılan iki modern toplama yaklaşımı olan G1GC ve ZGC’yi ve uygulamanızda kullanabileceğiniz ölçüm + ayar + kod pratiklerini anlatıyoruz.</p><h4>GC Neden Var?</h4><p>JVM’in amacı, program çalışırken “artık kullanılmayan” (reachable olmayan) nesnelerin belleğini geri almak. Garbage Collector (Çöp Toplayıcı), uygulama iş parçacıklarının ürettiği objelerin yaşam döngüsünü izler ve heap üzerinde “hangi objeler hâlâ erişilebilir?” sorusunun cevabına göre bellek kazanır.</p><p>GC’nin maliyeti iki şekilde gelir:</p><ul><li>CPU maliyeti: Mark/sweep/compact işlemleri kaynak tüketir.</li><li>Latency maliyeti: Bazı adımlar için uygulama iş parçacıkları duraklatılabilir. (Örn. stop-the-world / STW)</li></ul><p>Dolayısıyla hedef genelde şudur:</p><ul><li>Heap’te “baskıyı” yönet,</li><li>Pause’ları (duraklamaları) ölç,</li><li>Toplayıcı seçimleri ve JVM ayarlarıyla “daha öngörülebilir” davranış elde et.</li></ul><h4>JVM Heap’i Nasıl Düşünülmeli?</h4><p>Kavramsal olarak GC genelde “nesnelerin kısa ve uzun yaşadığı” mantığıyla anlatılır (young/old). Modern collector’lar (özellikle G1GC) bunu daha farklı bir yapıyla uygular.</p><h4>G1GC: Region Tabanlı Heap</h4><p>G1GC, heap’i region denen parçalara bölerek çalışır. Bazı region’lar daha yoğun toplanır; uzun yaşayanlar diğer region’larda biriktirilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*t8ZLXVvvJz9CkKsO_oyJVA.png" /><figcaption><a href="https://gemini.google.com/">Görsel Referansı</a></figcaption></figure><h4>ZGC: Düşük Pause Hedefi</h4><p>ZGC, amaç olarak pause sürelerini çok düşürmeye odaklanır. Bunu heap’i “regionlara bölüp duraklayarak taşımak” yerine, farklı bir yaklaşım ve eşzamanlı/aktarım mekanizmasıyla hedefler.</p><p>Bu sayede “pause yüzünden akışın bozulması” daha az olur (genelde çok düşük milisaniye altı seviyeler hedeflenir).</p><h4>GC Döngüsünün Temel Akışı</h4><p>Neredeyse tüm GC yaklaşımında ortak bir şablon var:</p><ol><li>Uygulama objeler üretir (allocation).</li><li>Heap dolmaya yaklaşınca GC tetiklenir.</li><li>“Yaşayan objeler” işaretlenir (mark).</li><li>Artık kullanılmayan alanlar serbest bırakılır (sweep) ve/veya yaşayanlar taşınarak yer toparlanır (compact/relocation).</li><li>Uygulama devam eder.</li></ol><p>Aşağıdaki şema özellikle G1GC/ZGC ayrımını anlamaya yardım eder: bazı adımlar uygulamayı durdurur, bazıları eşzamanlı olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*XwqdfcNDvlx8fwaX76qVZA.png" /><figcaption><a href="https://gemini.google.com/">Görsel Referansı</a></figcaption></figure><h4>G1GC Nedir?</h4><p>G1GC (Garbage-First), büyük heap’lerde “en çok çöpe sahip region’ları önce” toplayarak pause’ları hedeflemeye çalışır.</p><h4>G1GC’nin Kritik Kavramları</h4><ul><li>Region: Heap parçalara bölünür.</li><li>Evacuation / Mixed collections: Young+Old arası karışık toplama dönemleri.</li><li>Pause hedefi: -XX:MaxGCPauseMillis gibi ayarlar “hedeflenen” duraklama mantığıyla çalışır (tam garantidir diyemezsin; heap baskısı ve çalışma şekli etkiler).</li></ul><h4>G1GC’yi Çalıştırmak İçin Örnek JVM Komutu</h4><p>Java 17/21 gibi modern sürümlerde örnek:</p><pre>java -XX:+UseG1GC \<br>  -Xms2g -Xmx2g \<br>  -XX:MaxGCPauseMillis=200 \<br>  -Xlog:gc*:stdout:time,level,tags \<br>  -jar app.jar</pre><ul><li>-Xms/-Xmx: Heap’i sabitlemek (çoğu senaryoda) GC davranışını daha öngörülebilir yapar.</li><li>-XX:MaxGCPauseMillis: G1GC’nin daha “pause odaklı” kararlar almasına yardımcı olur.</li><li>-Xlog:gc*...: Modern JVM’de GC log için “unified logging” kullanılır.</li></ul><h4>ZGC Nedir?</h4><p>ZGC (Z Garbage Collector) “düşük duraklama” odaklı tasarlanmıştır. Özellikle latency hassas uygulamalarda (ör. istek gecikmesi hassas API’ler) tercih edilir.</p><h4>ZGC’nin Pratik Beklentisi</h4><ul><li>Uygulama duraklamaları genelde çok düşüktür.</li><li>CPU tüketimi ve RAM davranışı bazı durumlarda artabilir; bu yüzden ölçmeden “ZGC daha iyidir” demek doğru olmaz.</li></ul><h4>ZGC’yi Çalıştırmak İçin Örnek JVM Komutu</h4><pre>java -XX:+UseZGC \<br>  -Xms2g -Xmx2g \<br>  -Xlog:gc*:stdout:time,level,tags \<br>  -jar app.jar</pre><p>ZGC tarafında çok kullanılan bazı parametreler:</p><ul><li>-XX:SoftMaxHeapSize: Heap büyümesini “yumuşak” sınırla kontrol etme</li><li>-XX:ZUncommitDelay: Serbest bırakma davranışı (memory footprint için)</li></ul><p>(Parametrelerin etkisi sürüm ve workload’a göre değişebilir; o yüzden bunları “buluntu” değil “ölçüm” ile kullan.)</p><h4>En Pratik Yaklaşım: GC’yi Gör, Ölç, Sonra Ayarla</h4><p>GC’ye “tuning” yapmanın en sağlam yolu: önce <em>kanıt</em> topla.</p><h4>Unified GC log’ları al (hem G1 hem ZGC)</h4><p>En basit hali:</p><pre>-Xlog:gc*:stdout:time,level,tags</pre><p>Daha hedefli örnek (pause odaklı):</p><pre>-Xlog:gc+pause=info,gc+heap=info,gc+ref*=debug:stdout:time,level,tags</pre><h4>JFR (Java Flight Recorder) İle Olaylara Bak</h4><p>JFR, GC ve latency korelasyonu için çok değerlidir.</p><p>Çalışan JVM PID’sini bul (ör. jps ile) ve:</p><pre>jcmd &lt;pid&gt; JFR.start name=gcprofile settings=profile<br># ... uygulama yük altında kalsın ...<br>jcmd &lt;pid&gt; JFR.stop name=gcprofile</pre><p>Sonra raporu JDK araçlarıyla inceleyebilirsin (örn. Java Mission Control / jfr print).</p><h4>Pratik Kod: GC’yi Tetikle, Davranışı Gözle (Mini Playground)</h4><p>Aşağıdaki program, farklı boyutlarda objeler üretip yaşam döngülerini değiştirir. Bu sayede GC loglarında “pause/throughput” farklarını görmeye çalışabilirsin.</p><h4>GcPlayground.java</h4><pre>import java.util.ArrayList;<br>import java.util.List;<br>import java.util.concurrent.TimeUnit;<br><br>public class GcPlayground {<br><br>    // Ne kadar büyük nesne üretirsek heap üzerindeki baskı o kadar değişir.<br>    // G1GC&#39;de çok büyük objeler &quot;humongous&quot; etkisi yaratabilir (region büyüklüğüne bağlı).<br>    static byte[] allocate(int sizeKb) {<br>        return new byte[sizeKb * 1024];<br>    }<br><br>    public static void main(String[] args) throws Exception {<br>        int iterations = Integer.parseInt(args.length &gt; 0 ? args[0] : &quot;200&quot;);<br>        int burstKb = Integer.parseInt(args.length &gt; 1 ? args[1] : &quot;256&quot;); // 256KB örnek<br>        int holdEvery = Integer.parseInt(args.length &gt; 2 ? args[2] : &quot;5&quot;); // her N döngüde bir referans tut<br><br>        // Long-lived heap baskısı için bazı objeleri listede tutuyoruz.<br>        List&lt;byte[]&gt; longLived = new ArrayList&lt;&gt;();<br><br>        for (int i = 0; i &lt; iterations; i++) {<br>            // Kısa ömürlü objeler (young alanlarında daha çok dönecek)<br>            byte[] a = allocate(burstKb);<br>            byte[] b = allocate(burstKb);<br>            byte[] c = allocate(burstKb);<br><br>            // Bir kısmını referanslayıp yaşat: GC&#39;nin &quot;yaşıyor&quot; diye işaretlediği senaryo<br>            if (i % holdEvery == 0) {<br>                longLived.add(a);<br>            }<br><br>            // Küçük bir gecikme: steady-state için<br>            TimeUnit.MILLISECONDS.sleep(10);<br><br>            // Opsiyonel: listeden bir kısmını çıkararak &quot;yaşıyor&quot; setini oynat<br>            if (longLived.size() &gt; 2000) {<br>                longLived.subList(0, 1000).clear();<br>            }<br>        }<br><br>        // Not: System.gc() GC&#39;yi garanti etmez; sadece demo amaçlı.<br>        // Üretimde bunu kullanma.<br>        System.out.println(&quot;Finished allocation. longLived size=&quot; + longLived.size());<br>    }<br>}</pre><h4>Çalıştırma Örnekleri</h4><p><strong>G1GC:</strong></p><pre>javac GcPlayground.java<br>java -XX:+UseG1GC -Xms2g -Xmx2g \<br>  -Xlog:gc+pause=info,gc+heap=info:stdout:time,level,tags \<br>  GcPlayground 400 512 4</pre><p><strong>ZGC:</strong></p><pre>java -XX:+UseZGC -Xms2g -Xmx2g \<br>  -Xlog:gc+pause=info,gc+heap=info:stdout:time,level,tags \<br>  GcPlayground 400 512 4</pre><p>Loglarda özellikle şu sinyallere bak:</p><ul><li>Toplam GC sayısı (collections)</li><li>Pause event’lerinin frekansı ve süresi</li><li>Heap occupancy pattern’leri (heap doluyor mu, ne kadar toparlıyor?)</li></ul><h4>Performans Pratikleri</h4><h4>Ölçümle başla, “GC pause”ı Hedefle</h4><p>Önce sorunu netleştir:</p><ul><li>“Throughput sorunu mu var?” (CPU/işlem hızı)</li><li>“Latency sorunu mu var?” (tekil istek gecikmeleri)</li></ul><p>G1GC ve ZGC’nin güçlü yanları farklı, ama ikisi de doğru metrikle değerlendirilince anlam kazanıyor.</p><h4>Heap Boyutunu Doğru Planla</h4><ul><li>-Xms ve -Xmx dengesini workload’a göre ayarla.</li><li>Container ortamlarında JVM heap boyutu otomatik ayarlanabilir; yine de log ve JFR ile doğrula.</li></ul><p>Kötü bir başlangıç: “Ben GC’yi ayarlarım, heap’i otomatik bırakırım” demek. Otomatik de olabilir ama doğrulama şart.</p><h4>Allocation Baskısını Azalt</h4><p>GC’yi “daha hızlı yapmak” yerine “daha az iş çıkarmak” çoğu zaman kazanır:</p><ul><li>gereksiz objeleri azalt (ör. ara koleksiyonlar)</li><li>string/byte dizileriyle gereksiz kopyalamayı azalt</li><li>doğru veri yapısını seç</li></ul><h4>Uzun Ömürlü Referanslar (Long-lived Objects) Dikkat İster</h4><p>Uzun yaşarsa GC “yaşıyor” diye işaretlediği set büyür. Bu da hem işaretleme hem de boşluk yönetimini zorlaştırır.</p><p>Pratik yaklaşım:</p><ul><li>Büyük cache’leri ölç: büyüyüp büyüyemediğini takip et</li><li>Cache eviction stratejisini test et</li><li>Ref leak (yanlış elde tutulan referanslar) olup olmadığını incele</li></ul><h4>G1GC İçin “humongous” Etkisini Aklında Tut</h4><p>Çok büyük tekil objeler, region mantığı nedeniyle özel davranışlar tetikleyebilir. Bu yüzden:</p><ul><li>Tek seferde dev byte[]/buffer üretmek yerine parçalara ayırmayı test et</li><li>G1 loglarında büyük objelerin etkisini gözle</li></ul><h4>ZGC Seçimi: Düşük Pause Hedefin Varsa Anlamlıdır</h4><p>ZGC genelde “pause hassasiyeti” yüksek sistemlerde tercih edilir. Ama:</p><ul><li>CPU maliyeti artabilir</li><li>Bellek davranışı senaryoya göre değişir</li></ul><p>Bu yüzden “latency p99/p999” gibi metriklerle kıyas yap.</p><h4>Sonuç</h4><ul><li>G1GC: Orta-yüksek heap’lerde “pause hedefi” ile dengeli çalışmayı amaçlar; modern JVM’de çok yaygın.</li><li>ZGC: Çok düşük duraklamalar hedefler; latency hassasiyette parlayabilir.</li><li>En iyi yaklaşım: önce log/JFR ile gerçeği gör, sonra collector ve heap ayarlarını hedefe göre seç.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RKUE9Dg9i1GvOmBlZK5RXg.jpeg" /></figure><h4>Referanslar</h4><ul><li><a href="https://docs.oracle.com/en/java/javase/21/gctuning/introduction-garbage-collection-tuning.html">HotSpot Virtual Machine Garbage Collection Tuning Guide</a></li><li><a href="https://docs.oracle.com/en/java/javase/21/gctuning/z-garbage-collector.html">HotSpot Virtual Machine Garbage Collection Tuning Guide</a></li><li><a href="https://docs.oracle.com/en/java/javase/21/core/java-logging.html">JDK 26 Documentation - Home</a></li><li><a href="https://docs.oracle.com/en/java/javase/21/docs/specs/man/jcmd.html">The jcmd Command</a></li><li><a href="https://openjdk.org/jeps/333">JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bba4db14f2fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-student-developers-turkiye/jvmde-garbage-collection-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-g1gc-zgc-ve-performans-pratikleri-bba4db14f2fa">JVM’de Garbage Collection Nasıl Çalışır? G1GC, ZGC ve Performans Pratikleri</a> was originally published in <a href="https://medium.com/huawei-student-developers-turkiye">HUAWEI Student Developers Turkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SonarQube Nedir ? Spring Boot Projesi Üzerinde Kod Kalitesi Analizi]]></title>
            <link>https://medium.com/@hsdinonu/sonarqube-nedir-spring-boot-projesi-%C3%BCzerinde-kod-kalitesi-analizi-613538a490d9?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/613538a490d9</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[sonarqube]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Wed, 25 Mar 2026 18:44:21 GMT</pubDate>
            <atom:updated>2026-03-25T18:45:25.436Z</atom:updated>
            <content:encoded><![CDATA[<h3>SonarQube Nedir ? Spring Boot Projesi Üzerinde Kod Kalitesi Analizi</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xUiBq1fHc4Kv-e-hG1eZSw.png" /><figcaption><a href="https://firefly.adobe.com/"><strong>Görsel Referansı</strong></a></figcaption></figure><p><strong>Giriş</strong></p><p>Günümüzde yazılım geliştirme sürecinde yalnızca çalışan kod yazmak yeterli değildir. Yazılan kodun sürdürülebilir, okunabilir ve hatalardan arındırılmış olması da en az işlevselliği kadar önemlidir. Özellikle büyüyen projelerde kod kalitesini manuel olarak kontrol etmek oldukça zor hale gelir.</p><p>İşte bu noktada <strong>SonarQube</strong> devreye girer. <strong>SonarQube</strong>, statik kod analizi yaparak projelerdeki hataları, güvenlik açıklarını ve kötü kod yapılarını (bakımı zor kodlar) tespit eden güçlü bir araçtır.</p><p>Bu yazıda, bir <strong>Spring Boot</strong> projesi üzerinden <strong>SonarQube’un</strong> nasıl kurulduğunu, nasıl analiz yapıldığını ve elde edilen sonuçların nasıl yorumlandığını adım adım inceleyeceğiz.</p><p><strong>SonarQube’un Spring Boot Projesine Entegre Edilmesi</strong></p><p>İlk olarak <strong>Docker</strong> kullanarak bir <strong>SonarQube container’ı</strong> oluşturacağız. Ardından, Spring Boot projemize gerekli bağımlılıkları ekleyerek bu projeyi <strong>SonarQube</strong> sistemine bağlayacağız ve kod kalitesi analizini gerçekleştireceğiz. Bu sayede :</p><ul><li>SonarQube’u Docker ile çalıştırmayı</li><li>Spring Boot projesini SonarQube’a entegre etmeyi</li><li>Kod analizi sonuçlarını yorumlama</li></ul><p>hakkında bilgi sahibi olacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DLr2w8M2yXsdQ_G80Ny4iA.png" /><figcaption><a href="https://firefly.adobe.com/"><strong>Görsel Referans</strong></a></figcaption></figure><p><strong>1.SonarQube’u Docker ile Container Oluşturma</strong></p><p>Docker’da <strong>SonarQube Container’i</strong> oluşturmak için komut çalıştırmamız gerekiyor. Komutun başarılı bir şekilde çalışması için Docker Desktop’u açmak gerekmektedir.</p><pre>docker run -d --name sonarqube -p 9000:9000 sonarqube</pre><p>Komutun çalıştırılmasıyla birlikte Docker gerekli imajları indirir ve SonarQube container’ı başlatılır ve sonrasında <strong>Docker Desktop</strong> üzerinden container’ın aktif olduğu görülebilir. Tarayıcıdan http://localhost:9000 adresine giderek <strong>SonarQube</strong> ara yüzüne erişim sağlanır.</p><p>Ara yüzde bizi ilk giriş sayfası karşılar. Varsayılan kullanıcı adı ve şifre “<strong>admin</strong>” olarak belirlenmiştir. Güvenlik nedeniyle, giriş yaptıktan sonra sistem kullanıcıdan şifreyi değiştirmesini ister.</p><p><strong>2.SonarQube Yerel Proje Oluşturma</strong></p><p>Giriş işlemi tamamlandıktan sonra bizi SonarQube ana sayfası karşılar. Analiz yapabilmek için öncelikle projemizi sisteme tanıtmamız gerekir. Bu nedenle ana sayfada yer alan <strong>“Create a Local Project”</strong> butonuna tıklayarak yeni bir proje oluştururuz.</p><p>Proje oluşturma adımında; proje adı (Project Name), proje anahtarı (Project Key) ve branch bilgileri girilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lRb_qUgUJXVolIaWv8PCXg.png" /></figure><p>Kurulum (Set Up) aşamasında ise varsayılan ayarlar seçilerek işlem tamamlanabilir. Diğer seçenek size uygunsa onu da seçebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xEDqNPC4grGPOg_MynNRRQ.png" /></figure><p>Bu işlem sonucunda oluşturulan proje, yapılacak analizlerin saklanacağı ve sonuçların görüntüleneceği alanı temsil eder.</p><p>Proje anahtarımız belli olduğuna göre sıra Token oluşturmada. Token ve Key çok önemlidir çünkü Spring Boot projesine, bu iki bilgiyle<strong>(Key ve Token)</strong> başvuracağız.</p><p><strong>3.SonarQube’da Token Oluşturma</strong></p><p>Account(Hesabım) sayfasında, Security(Güvenlik) bölümünde bizlere <strong>Token</strong> oluşturma sayfası çıkar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OCf-nSElsYRn5sYLMend9A.png" /></figure><p>Token Adını, Token Tipini(<strong>Project Analysis Token</strong>) ve Token’in <strong>ne kadar süre aktif olacağını</strong> belirleyip oluştururuz. Oluşturduğumuzda bize <strong>Token </strong>verir ve bu <strong>Token’i </strong>bir yerde tutmanız gerekir <strong>çünkü bir daha gösterilmez</strong>.</p><p><strong>4.Spring Boot Projesi Oluşturma</strong></p><p>Spring Boot projesinin <strong>SonarQube</strong> ile analiz edilebilmesi için Maven yapılandırma dosyası olan pom.xml içerisine gerekli <strong>plugin</strong> ve <strong>properties</strong>(ayarlar) eklenmesi gerekmektedir.</p><pre>&lt;properties&gt;<br>    &lt;sonar.projectKey&gt;SonarQubeProject&lt;/sonar.projectKey&gt;<br>    &lt;sonar.host.url&gt;http://localhost:9000&lt;/sonar.host.url&gt;<br>&lt;/properties&gt;</pre><p>Proje oluşturma aşamasında belirlenen <strong>Project Key</strong> değerinin, analiz işlemi sırasında doğru şekilde belirtilmesi gerekmektedir. Bu nedenle sonar.projectKey alanına, proje oluştururken tanımladığımız anahtar girilmelidir.</p><pre>&lt;build&gt;<br>    &lt;plugins&gt;<br>        &lt;plugin&gt;<br>            &lt;groupId&gt;org.sonarsource.scanner.maven&lt;/groupId&gt;<br>            &lt;artifactId&gt;sonar-maven-plugin&lt;/artifactId&gt;<br>        &lt;/plugin&gt;<br>    &lt;/plugins&gt;<br>&lt;/build&gt;</pre><p>Yukarıdaki yapı Spring Boot projesini SonarQube ile analiz edebilmek için gerekli olan Maven eklentisini (plugin) projeye dahil eder.</p><p>Şimdi, Spring Boot projesi üzerinde bilinçli olarak yazılmış kötü ve iyileştirilmiş kod örnekleri üzerinden <strong>SonarQube’un</strong> analiz sonuçlarını inceleyeceğiz.</p><p><strong>Kötü Kod</strong></p><pre>@Service<br>public class UserService {<br><br>    public String getUserName(String name) {<br><br>        String password = &quot;123456&quot;;<br><br>        if(name != null) {<br>            if(name.length() &gt; 0) {<br>                return name.toLowerCase();<br>            }<br>        }<br><br>        return null;<br>    }<br><br>    public void printUsers() {<br>        for(int i = 0; i &lt; 10; i++) {<br>            if(i % 2 == 0) {<br>                if(i &gt; 5) {<br>                    System.out.println(i);<br>                }<br>            }<br>        }<br>    }<br><br>}</pre><p>Kötü kod örneğimize baktığımız zaman şifremizin(password) açıkta olduğunu, if içinde if kullanıldığını, null dönmesinin bug riski taşıdığını ve <strong>printUsers</strong> fonksiyonunun karmaşık bir yapıda olduğunu görmekteyiz.</p><p><strong>Şimdi Test Zamanı</strong></p><pre>mvn sonar:sonar &quot;-Dsonar.token=YOUR_TOKEN&quot;</pre><p>Maven üzerinden çalıştırılan mvn sonar:sonar komutu, proje kodlarının <strong>SonarQube </strong>tarafından analiz edilmesini sağlar. Komuta eklenen -Dsonar.token parametresi ise <strong>SonarQube </strong>sunucusuna kimlik doğrulama amacıyla kullanılır. Bu işlem sonucunda analiz verileri <strong>SonarQube </strong>dashboard üzerinde görüntülenebilir.</p><p>YOUR_TOKEN, SonarQube tarafından üretilen ve yalnızca bir kez görüntülenebilen bir kimlik doğrulama anahtarıdır. Bu token, analiz işlemi sırasında yetkilendirme amacıyla kullanılır. Size sağlanan bu token ile <strong>terminal üzerinden gerekli komutu çalıştırarak</strong> projenizin <strong>SonarQube </strong>tarafından analiz edilmesini başlatabilirsiniz.</p><p><strong>Kötü Kod Test Sonucu</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U8Vb9B23QCFKgoC0JIXNBA.png" /></figure><p>Dashboard açıklaması :</p><ul><li><strong>Security :</strong> Kod içerisindeki gerçek güvenlik açıklarını ifade eder.</li><li><strong>Reliability </strong>: Kodun hata verme olasılığını gösterir.</li><li><strong>Maintainability :</strong> Kodun okunabilirliği ve sürdürülebilirliği ile ilgilidir.</li><li><strong>Hotspots Reviewed :</strong> Potansiyel güvenlik riskleridir.</li><li><strong>Coverage :</strong> Testlerin kodu ne kadar kapsadığını gösterir.</li><li><strong>Duplications :</strong> Kod tekrarını gösterir.</li></ul><p>Analiz sonuçları incelendiğinde, Security (güvenlik) kategorisinde 1 adet güvenlik açığı, Maintainability (bakım) kategorisinde ise 6 adet kod kalitesi problemi tespit edilmiştir ve bundan dolayı “<strong>Failed” </strong>vermiştir.</p><p>Şimdi güvenlik açığı ve kod kalitesinde problem olanların neler olduğuna bakalım.</p><p><strong>Güvenlik Açığı Problemi Açıklaması</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*0Rb6XNszNa681_wkPLufgg.png" /></figure><ul><li>SonarQube, kod içerisinde sabit olarak tanımlanmış “password” ifadesini güvenlik açığı olarak tespit etmiştir. Hardcoded parola kullanımı, hassas bilgilerin açığa çıkmasına neden olabileceğinden önerilmez.</li></ul><p><strong>Kod Kalitesi Problemleri Açıklaması</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*SgJy-8n9OyVdAoMD594avw.png" /></figure><ul><li>Yerel değişken password için yapılan gereksiz atamanın kaldırılması önerilmektedir.</li><li>Kullanılmayan password değişkeninin koddan temizlenmesi gerekmektedir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*wuDrY1tAp2gnnQpGgmsIpw.png" /></figure><ul><li>İç içe yazılmış if yapılarının birleştirilerek daha sade ve okunabilir hale getirilmesi önerilmektedir.</li><li>String kontrolü yapılırken daha uygun bir yöntem olan isEmpty() veya benzeri fonksiyonların kullanılması tavsiye edilmektedir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*5QSybAWaiXrcGVgySgZZpg.png" /></figure><ul><li>İç içe yazılmış if yapılarının birleştirilerek daha sade ve okunabilir hale getirilmesi önerilmektedir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*tUx21ea9f1fdKKPw8NiO4g.png" /></figure><ul><li>System.out.println kullanımı yerine bir loglama mekanizmasının tercih edilmesi önerilmektedir.</li></ul><p>Kötü Kodu iyileştirelim ve <strong>SonarQube </strong>analiz sonucunu tekrar kontrol edelim.</p><p><strong>İyileştirilmiş Kod</strong></p><pre>@Service<br>public class UserService {<br><br>    private static final Logger logger = LoggerFactory.getLogger(UserService.class);<br><br>    public String getUserName(String name) {<br>        if(name == null || name.isBlank()) {<br>            return &quot;Unknown&quot;;<br>        }<br><br>        return name.toLowerCase();<br>    }<br><br>    public void printUsers() {<br>        for(int i = 6; i &lt; 10; i++) {<br>            if(i % 2 == 0) {<br>                logger.info(&quot;User index: {}&quot;, i);<br>            }<br>        }<br>    }<br>}</pre><p><strong>Şimdi Test Zamanı</strong></p><pre>mvn sonar:sonar &quot;-Dsonar.token=YOUR_TOKEN&quot;</pre><p>Komutunu proje terminalinde çalıştıralım.</p><p><strong>İyileştirilmiş Kod Test Sonucu</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zh32H4-vt70Xgti2x-gPvA.png" /></figure><p>Kod üzerinde gerçekleştirilen düzenlemeler sonrasında analiz tekrar çalıştırılmış ve tüm kalite kriterlerinin başarıyla sağlandığı görülmüştür. Önceki aşamada tespit edilen güvenlik ve bakım problemleri giderilmiş, proje <strong>SonarQube </strong>kalite kontrollerinden “<strong>Passed</strong>” sonucu almıştır.</p><p>Bu süreç, statik kod analiz araçlarının yazılım geliştirme sürecinde ne kadar önemli bir rol oynadığını açıkça göstermektedir.</p><p><strong>Sonuç</strong></p><p><strong>SonarQube</strong>, yazılım projelerinde statik kod analizi gerçekleştirerek hataları, güvenlik açıklarını ve bakımı zor kod yapılarını tespit eden etkili bir araçtır. Düzenli olarak kullanıldığında, projelerdeki bakım yükünün azaltılmasına, kod kalitesinin artırılmasına ve sürdürülebilir yazılım geliştirme süreçlerinin oluşturulmasına katkı sağlar. Bu sayede ekipler, yalnızca mevcut sorunları hızlıca çözmekle kalmaz, aynı zamanda uzun vadede daha sağlam, güvenli ve bakımı kolay yazılımlar ortaya çıkarabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*-hQf2bEqhtRwx7juacLdFA.png" /></figure><p><strong>Referanslar</strong></p><ul><li><a href="https://docs.sonarsource.com/">Home | Sonar Documentation</a></li><li><a href="https://www.geeksforgeeks.org/advance-java/integration-of-sonarqube-with-springboot/">Integration of SonarQube with SpringBoot - GeeksforGeeks</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=613538a490d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PyTorch ile Görüntü Sınıflandırma Uygulaması]]></title>
            <link>https://medium.com/@hsdinonu/pytorch-ile-g%C3%B6r%C3%BCnt%C3%BC-s%C4%B1n%C4%B1fland%C4%B1rma-uygulamas%C4%B1-753bae935e15?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/753bae935e15</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[image-classification]]></category>
            <category><![CDATA[artificial-neural-network]]></category>
            <category><![CDATA[pytorch]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 13:15:13 GMT</pubDate>
            <atom:updated>2026-03-17T13:15:50.493Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ar0IEPG7K1wBcErnSwO0vg.png" /><figcaption><a href="https://gemini.google.com/app">Görsel Referansı</a></figcaption></figure><h3>Giriş</h3><p>Görüntü sınıflandırma, piksellerden oluşan ham verinin belirli algoritma katmanlarından geçerek anlamlandırılması sürecidir. Bu süreçte temel yapı taşı olan <strong>Yapay Sinir Ağları (ANN)</strong>, insan beynindeki nöronların çalışma prensibini taklit ederek her bir piksel değerini öznitelik haritalarına dönüştürür ve veriyi matematiksel işlemlerle belirli sınıflara ayırır.</p><p>Bu yazıda, bir görüntü sınıflandırma modelinin geliştirilme aşamalarını; veri setinin hazırlanmasından Yapay Sinir Ağları (ANN) temelli modelin oluşturulmasına kadar adım adım ve teknik detaylarıyla inceleyeceğiz.</p><h4><strong>Problem Tanımı: MNIST Veri Seti ile Görüntü Sınıflandırma</strong></h4><p>Bu projenin temel amacı, <strong>MNIST</strong> veri setini kullanarak bir görüntü sınıflandırma modeli geliştirmektir. Uygulama aşamasında, derin öğrenme veya <strong>görüntü sınıflandırma</strong> projelerinde sıklıkla kullanılan Python tabanlı <strong>PyTorch</strong> kütüphanesinden yararlanılacaktır.</p><p><strong>MNIST Veri Seti Nedir?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*lmU_j0j7tNkpzixRxSWPSg.png" /><figcaption><a href="https://en.wikipedia.org/wiki/MNIST_database">Görsel Referansı</a></figcaption></figure><p>MNIST (<strong>Modified National Institute of Standards and Technology database</strong>) veri seti, <strong>NIST’in</strong> orijinal veri kümelerinden örneklerin “yeniden karıştırılması“ ile oluşturulmuştur.<br>MNIST, çeşitli görüntü işleme sistemlerinin eğitimi için kullanılan bir el yazısı rakam veritabanıdır. Bu veri seti <strong>60.000 eğitim verisi</strong> ve <strong>10.000 test verisi</strong> içermektedir; bu nedenle makine öğrenimi ve görüntü işleme sistemlerinde yaygın olarak kullanılmaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*7I1hKusMBhuoPZIGbvTfCw.png" /></figure><p>Bu proje, ham verinin işlenip tahmin üreten bir modele dönüştüğü dört kritik teknik fazdan oluşmaktadır:</p><ol><li><strong>Veri Setinin Hazırlanması: </strong>Verilerin indirilmesi, normalize edilmesi ve eğitim/test gruplarına ayrılarak “DataLoader” yapılarına aktarılması.</li><li><strong>Modelin Oluşturulması:</strong> Yapay Sinir Ağları (ANN) mimarisinin PyTorch sınıfları kullanılarak oluşturulması.</li><li><strong>Modelin Eğitilmesi: </strong>Belirlenen optimizasyon algoritmaları ve kayıp fonksiyonları (loss functions) eşliğinde modelin veriden öğrenme sürecinin yönetilmesi.</li><li><strong>Test ve Değerlendirme: </strong>Modelin daha önce görmediği test verileri üzerindeki başarımının ölçülmesi ve çıktıların doğruluk oranı <strong>(accuracy)</strong> gibi metriklerle analiz edilmesi.</li></ol><p><strong>Gerekli Kütüphanelerin Kurulması ve İçe Aktarılması</strong></p><p>Görüntü işleme ve yapay zeka uygulamaları denilince akla en çok gelen programlama dili Python’ dur. Python’nun sunmuş olduğu basit ve sade dil bu karmaşık işlemlerin kolayca yapılmasını sağlamaktadır. Bu uygulamada deep learning, görüntü sınıflandırma ve makine öğrenmesi gibi alanlarda çokça kullanılan <strong>PyTorch</strong> kütüphanesini kullanacağız.</p><pre>import torch  # Temel kütüphane, tensör işlemleri ve hesaplamalar<br>import torch.nn as nn  # Sinir ağı katmanları ve mimari yapısı<br>import torch.optim as optim  # Model parametrelerini güncelleyen algoritmalar<br>import torchvision  # Hazır veri setleri ve görüntü işleme araçları<br>import torchvision.transforms as transforms  # Görüntü dönüşümleri/vektör<br>import matplotlib.pyplot as plt # Grafik/Görsel Oluşturma</pre><p><strong>Modelin Eğitilmesi İçin Cihaz Belirlenmesi</strong></p><p>Modelin eğitilmesi; bu tip uygulamaların temel aşamasıdır ve oldukça önemlidir. Model eğitilirken; on binlerce verinin ve bir o kadar etiketin olduğu veri setleri kullanılır. Bu kadar büyük verinin işlenmesi için elbette oldukça güçlü donanıma ihtiyaç duyulur. Burada da akla <strong>GPU</strong> veya<strong> CPU</strong> gelir. Bu uygulamada ise cuda, yani GPU kullanacağız.</p><pre>device=torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;) # eğer gpu yoksa cpu yu kullan</pre><p><strong>1 — Veri Setinin Yüklenmesi</strong></p><p>Modelin eğitimi için ham verilerin hazırlanması gerekir. Hazırladığımız get_data_loaders fonksiyonu, ham görüntüyü modele hazır hale getirir. Görüntü ToTensor() ile matrise çevrilir.</p><p>Veri seti train_set ve test_set olmak üzere ikiye ayrılır. Bu ayrım train=True/False ile yapılır.</p><p>Veriler batch_size parametresi ile küçük gruplara ayrılır. Eğitim setinde shuffle=True kullanılarak modelin verilerin sırasını <strong>ezberlemesi</strong> engellenir.</p><pre>def get_data_loaders(batch_size=64): # Her iteresyonda işlenecek veri miktarı -&gt;64<br><br>    transform=transforms.Compose([transforms.ToTensor(),<br>                        transforms.Normalize((0.5,),(0.5,))]) #görüntüyü tensore çevirir<br>    <br>    #mnist veri seti indir ve eğtim test kumelerini oluştur<br>    train_set = torchvision.datasets.MNIST(root=&quot;./data&quot;,train=True,download=True,transform=transform)<br>    test_set = torchvision.datasets.MNIST(root=&quot;./data&quot;,train=False,download=True,transform=transform)<br>    <br>    #pytorch veri yükleyicisi oluştur<br>    train_loader = torch.utils.data.DataLoader(train_set,batch_size=batch_size,shuffle=True)<br>    test_loader = torch.utils.data.DataLoader(test_set,batch_size=batch_size,shuffle=False)<br><br>    return train_loader,test_loader<br><br>train_loader,test_loader=get_data_loaders()</pre><p><strong>1.1 — Veri Görselleştirme</strong></p><p>Veri setini başarıyla yükledikten sonra, verilerin doğru şekilde işlenip işlenmediğini kontrol etmek gerekir. visualize_samples fonksiyonu, yüklediğimiz verileri görselleştirerek etiketlerle görüntülerin uyumunu doğrulamamızı sağlar.</p><p>PyTorch görüntüleri genellikle <strong>(Kanal, Yükseklik, Genişlik</strong>) formatında tutar. MNIST <strong>siyah-beyaz</strong> olduğu için kanal boyutu 1&#39;dir. squeeze() ile bu gereksiz boyut atılarak <strong>matplotlib</strong> ile çizilebilir hale gelir. cmap=”gray” görüntülerin orijinal formatına uygun siyah-beyaz olarak gösterilmesini sağlar.</p><pre>def visualize_samples(loader,n):<br>    images,labels = next(iter(loader)) # ilk batch den görüntü ve etiketleri al<br>    fig,axes=plt.subplots(1,n,figsize=(10,5))<br>    for i in range(n):<br>        axes[i].imshow(images[i].squeeze(),cmap=&quot;gray&quot;)<br>        axes[i].set_title(f&quot;Label:{labels[i].item()}&quot;)<br>        axes[i].axis(&quot;off&quot;)<br>    plt.show()<br><br>visualize_samples(train_loader,4)</pre><p><strong>2 — ANN Modelinin Oluşturulması</strong></p><p>Veriyi hazırladıktan sonra, bu verileri işleyecek <strong>ANN</strong> modelini oluşturuyoruz. PyTorch’ ta modeller nn.Module sınıfından miras alınarak oluşturulur.</p><p>İlk aşamada, nn.Flatten() ile <strong>28x28</strong> boyutundaki iki boyutlu görüntü matrisini <strong>784</strong> piksellik bir vektör haline getiriyoruz. Yapay Sinir Ağlarının katmanlardan oluştuğunu biliyoruz, bunlar;</p><ul><li><strong>Input Layer: </strong>Girdi katmanı, modele verilerin alındığı self.flatten katmanıdır.</li><li><strong>Hidden Layer: </strong>Modelde iki tane tam bağıl katman fc1 ve fc2 kullanılarak pikseller arasındaki karmaşık ilişkiler öğrenilir.</li><li><strong>Output Layer:</strong> Son katman olan fc3, modelin görüntünün 0&#39;dan 9&#39;a kadar hangi rakama ait olduğunu tahmin ettiği çıktı katmanıdır.</li></ul><p>Katmanlar arasında kullanılan nn.ReLU() aktivasyon fonksiyonu, modelin öğrenme ve karar verme yeteneğini artırır.</p><pre>class NoralNetwork(nn.Module):<br><br>    def __init__(self):<br>        super(NoralNetwork,self).__init__()<br><br>        # Elimizde bulunan görüntüleri vektör haline çevirecegiz<br>        self.flatten= nn.Flatten() # ilk tam bağıl katmanı oluştur(Input Layer)<br><br>        self.fc1= nn.Linear(28*28,128)  <br>        self.relu=nn.ReLU()# aktivasyon fonksiyonunu tanımla<br>        self.fc2 = nn.Linear(128,64)# ikinci tam baglı katmanı oluştur<br>        self.fc3 = nn.Linear(64,10)# cıktı katmanını oluştur<br><br>    def forward(self,x): #forward propagation ; ileri yayılım -&gt; x:görüntü(28x28)<br>        <br>        x = self.flatten(x)<br>        x=self.fc1(x)<br>        x = self.relu(x)<br>        x = self.fc2(x)<br>        x=self.relu(x)  <br>        x = self.fc3(x)  <br><br>        return x  <br><br><br># Modeli oluştur ve cihazı ata.<br>model =NoralNetwork().to(device)</pre><p><strong>2.1 — Kayıp ve Optimizasyon Fonksiyonlarının Belirlenmesi</strong></p><p>Bir modelde en önemli şeylerden biri de <strong>kayıp</strong> ve <strong>optimizasyon</strong> fonksiyonlarıdır. nn.CrossEntropyLoss çok sınıflı sınıflandırma problemlerinde en çok kullanılan hata fonksiyonudur.</p><p>optim.Adam modelin ağırlıklarının güncellenmesini sağlayan optimizasyon algoritmasıdır. lr=0.001 ile öğrenme oranı ayarlanır, böylece eğitimin daha hızlı ve kararlı ilerlemesi sağlanır.</p><pre>define_loss_and_optimizer = lambda model:(<br>    nn.CrossEntropyLoss(), #hata fonksiyonu<br>    optim.Adam(model.parameters(),lr=0.001) # weights parametresi güncellenir<br>)<br>criterion,optimizer = define_loss_and_optimizer(model)</pre><p><strong>3 — Modelin Eğitilmesi</strong></p><p>Eğitim süreci, modelin tüm veri setini tekrar tekrar görerek hatalarından ders çıkardığı döngüsel bir süreçtir; buna <strong>epoch</strong> denir. epochs=5 parametresi, modelin tüm eğitim verisini 5 kez baştan sona işlemesini sağlar. model.train() ile model eğitim moduna alınır.</p><p>Bir hata listesi train_losses=[] oluşturularak her bir <strong>epoch</strong> sonunda hata değeri (loss) saklanır. İleri yayılım (Forward Propagation) ve geri yayılım (Backward Propagation) yapıldıktan sonra optimizer.step() ile ağırlıkların güncellenmesi yapılır. Böylelikle “<strong>öğrenme</strong>” gerçekleşir.</p><pre><br>def train_model(model,train_loader,criterion,optimizer,epochs=5):<br>    <br>    model.train() <br>    train_losses=[] # loss(hata) degerlerinin saklanması için bir liste.<br>    <br>    for epoch in range(epochs): <br>        total_loss=0<br><br>        for images,labels in train_loader: # tüm eğitim verileri üzerinde iterasyon gerçekleştir<br>            images,labels=images.to(device),labels.to(device)<br><br>            optimizer.zero_grad()# gradyanları sıfırla<br>    <br>            pradictions=model(images) # ileri yayılım<br>            loss = criterion(pradictions,labels) # loss hesaplama <br>            loss.backward() # geri yayılım <br>            optimizer.step() # weight parametrelirini güncelle<br><br>            total_loss +=loss.item()<br><br>        awg_loss = total_loss/len(train_loader)  # ortalama kayıp hesapla<br>        train_losses.append(awg_loss)<br>        print(f&quot;Epoch{epoch+1}/{epoch},Loss:{awg_loss:.3f}&quot;)<br><br>    plt.figure()<br>    plt.plot(range(1,epochs +1 ),train_losses,marker=&quot;o&quot;,linestyle=&quot;-&quot;,label=&quot;Train Loss&quot;)<br>    plt.xlabel(&quot;Epochs&quot;)<br>    plt.ylabel(&quot;Loss&quot;)<br>    plt.title(&quot;Train Loss&quot;)<br>    plt.legend()<br>    plt.show()<br><br>train_model(model,train_loader,criterion,optimizer,epochs=10) </pre><p><strong>4 — Modelin Test Edilmesi</strong></p><p>Eğitilen modelin, test veri seti üzerinden değerlendirilmesi uygulamanın son aşamasıdır. model.eval() modelin test edilebilmesi için öncelikle değerlendirme moduna alınmalıdır. Test aşamasında ağırlık güncellemesi yapılmadığından torch.no_grad() ile gradyan hesaplamaları tamamen kapatılır.</p><p>Test Accuracy: Bu metrik, yapılan doğru tahminlerin toplam test verisine oranıdır. Bu sayede modelin genel başarı yüzdesini görebiliriz.</p><pre>def test_model(model,test_loader):<br>    model.eval()<br>    correct=0  # dogru tahmin sayacı<br>    total=0  <br><br>    with torch.no_grad(): <br>        for images,labels in test_loader:<br>            images,labels = images.to(device),labels.to(device)<br>            predicition=model(images)<br>            _, predicition = torch.max(predicition,1)<br>            total+=labels.size(0)<br>            correct+=(predicition == labels).sum().item() #dogru ise sayılır<br>    <br>    print(f&quot;Test Accuracy :{100*correct/total:.3f}%&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*e_GI3mx0wZ2hIOI-WtVafg.png" /><figcaption><strong>Images-Label Eşleşmesi</strong></figcaption></figure><p>Veri Görselleştirme aşamasında gerçekleştirilen test sonucunda, <strong>Görüntü-Etiket</strong> (Images-Label) eşleşmesinin başarıyla tamamlandığı yukarıdaki görselde açıkça görülmektedir. Bu sayede modelin yanlış veriden öğrenme riskini ortadan kaldırarak ilerleyen aşamalar için güvenilir bir zemin oluşturulmaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/1*Dx0uEByrFc-iIi8wqPW9WQ.png" /><figcaption><strong>Epoch-Loss Grafiği</strong></figcaption></figure><p>Modelin, <strong>10 epochluk </strong>eğitiminden sonra oluşan <strong>Epochs-Loss</strong> grafiği yukarıdaki gibidir. Grafiğe bakıldığında her epoch’tan sonra loss (hata) oranın düştüğü görülmektedir. Bu durum, modelin el yazısı karakteristik özelliklerini her adımda daha iyi kavradığını ve <strong>ağırlıklarını (weights)</strong> optimize ettiğini göstermektedir.</p><p>Model tüm tahminlerinin sonucunda <strong>Test Accuracy</strong> değerinin <strong>%95.4 ‘</strong>e ulaşmıştır; bu da modelin yüksek bir genelleme yeteneğine ulaştığını ortaya koymaktadır.</p><h3>Sonuç</h3><p>Bu çalışmada, ham piksel verilerinden başlayarak el yazısı rakamları tanıyabilen bir <strong>Yapay Sinir Ağı (ANN) </strong>modeli inşa ettik. PyTorch kütüphanesinin sunduğu esneklik sayesinde, verinin ön işlenmesinden modelin eğitilmesine kadar tüm kritik aşamaları başarıyla yapılandırdık.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZp01YT35TSXf6Tvk1ibOg.png" /></figure><h3>Referanslar</h3><ul><li><a href="https://pytorch.org/?source=post_page-----42305a60a56e---------------------------------------">PyTorch</a></li><li><a href="https://levelup.gitconnected.com/artificial-neural-networks-anns-9ec2d198bbd8">Artificial Neural Networks (ANNs)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=753bae935e15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Etik Hacker Nedir? Siber Güvenliğin Görünmeyen Savunma Hattı]]></title>
            <link>https://medium.com/@hsdinonu/etik-hacker-nedir-siber-g%C3%BCvenli%C4%9Fin-g%C3%B6r%C3%BCnmeyen-savunma-hatt%C4%B1-20419b1df205?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/20419b1df205</guid>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 10:03:51 GMT</pubDate>
            <atom:updated>2026-03-05T10:09:08.396Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hoyph-1ublb2bK-DBvD78w.png" /></figure><h3>Giriş</h3><p>Dijital dünyada attığımız her adım bir veri üretir. Banka transferleri, e-posta yazışmaları, şirket içi belgeler, kimlik bilgilerimiz, hatta günlük alışkanlıklarımız bile dijital sistemlerde saklanır.</p><p>Bu sistemler her gün milyonlarca saldırı girişimine maruz kalır.</p><p>Peki bu saldırıları kim engelliyor?</p><p>Çoğu insan hacker kelimesini duyduğunda yasa dışı faaliyetleri düşünür. Oysa hacker kavramı teknik olarak bir sistemi derinlemesine anlayabilen kişiyi ifade eder. Hacker olmak, bir sistemi bozmak değil; onun nasıl çalıştığını ve nerede zayıf olduğunu anlayabilmektir.</p><p>Etik hacker ise bu bilgiyi savunma amacıyla kullanan profesyoneldir.</p><h3>Hacker Kavramının Evrimi</h3><p>Hacker kelimesi ilk ortaya çıktığında negatif bir anlam taşımıyordu. 1960’larda MIT’de “hacker”, sistemleri yaratıcı şekilde manipüle edebilen teknik uzman anlamına geliyordu.</p><p>Zamanla bu kavram iki farklı yöne ayrıldı:</p><ul><li><strong>Black Hat</strong>: Yetkisiz erişim sağlayan, zarar veren kişiler</li><li><strong>White Hat (Etik Hacker)</strong>: Sistem sahiplerinin izniyle güvenlik testi yapan uzmanlar</li></ul><p>Etik hacker’lık, teknik beceri ile hukuki ve etik sorumluluğun birleşimidir.</p><p>Bu meslek yalnızca teknik bilgi değil, profesyonel disiplin de gerektirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8f-w8sBoQ0CDkJzZ-ZH78g.png" /></figure><h3>Etik Hacker Ne Yapar? (Gerçek Süreç)</h3><p>Bir penetration test filmi andıran sahnelerden ibaret değildir. Oldukça sistematik ilerler.</p><h3>1 — Reconnaissance (Keşif)</h3><p>Hedef sistem hakkında bilgi toplanır:</p><ul><li>Alan adları</li><li>IP adresleri</li><li>Açık kaynak verileri</li><li>Kullanılan teknolojiler</li></ul><p>Bu aşama çoğu zaman saldırının kendisinden daha kritiktir. Çünkü doğru bilgi, doğru saldırı yüzeyini ortaya çıkarır.</p><h3>2 — Scanning ve Enumeration</h3><p>Sistemde:</p><ul><li>Hangi portlar açık?</li><li>Hangi servisler çalışıyor?</li><li>Hangi versiyonlar kullanılıyor?</li></ul><p>belirlenir.</p><p>Burada amaç rastgele deneme yapmak değil; sistemin haritasını çıkarmaktır.</p><h3>3 — Vulnerability Analysis</h3><p>Tespit edilen servislerde bilinen güvenlik açıkları olup olmadığı incelenir.</p><p>Örneğin:</p><ul><li>Güncellenmemiş bir web sunucusu</li><li>Zayıf parola politikası</li><li>Yanlış yapılandırılmış erişim izinleri</li></ul><p>Bu aşama analiz ve sabır gerektirir.</p><h3>4 — Controlled Exploitation</h3><p>Eğer bir açık doğrulanırsa, kontrollü ve izinli şekilde test edilir.</p><p>Buradaki amaç veri çalmak değildir.<br> Amaç açığın gerçekten risk oluşturduğunu kanıtlamaktır.</p><h3>5 — Reporting</h3><p>En kritik aşama burasıdır.</p><p>Etik hacker’lıkta başarı, sistemi kırmak değil; açıkları teknik ve anlaşılır şekilde raporlamaktır.</p><p>Profesyonel bir rapor şunları içerir:</p><ul><li>Açığın teknik açıklaması</li><li>Risk seviyesi (Low / Medium / High / Critical)</li><li>Nasıl istismar edilebileceği</li><li>Çözüm önerisi</li></ul><p>Gerçek değer burada ortaya çıkar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9P6uLablMm9huUoZrpWwUQ.png" /></figure><h3>Etik Hacker’ın Sahip Olması Gereken Bilgi Alanları</h3><p>Etik hacker’lık tek bir araç öğrenmek değildir. Çok disiplinli bir altyapı gerektirir.</p><h3>Ağ Bilgisi</h3><p>TCP/IP, DNS, HTTP, SSL/TLS gibi temel protokolleri anlamadan güvenlik yapılamaz.</p><h3>İşletim Sistemleri</h3><p>Özellikle Linux sistem yönetimi bilgisi kritik önemdedir.</p><h3>Web Uygulama Güvenliği</h3><p>OWASP Top 10 listesi burada referans noktasıdır. Örneğin:</p><ul><li>SQL Injection</li><li>Cross-Site Scripting (XSS)</li><li>Broken Authentication</li><li>Security Misconfiguration</li></ul><p>Bu açıklar çoğu zaman karmaşık değil; ihmalkârlık kaynaklıdır.</p><h3>Temel Kriptografi</h3><p>Hashing, encryption, certificate mantığını anlamak gerekir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9cdAs02SGYO8VDA1_ER2dg.png" /></figure><h3>İnsan Faktörü: En Büyük Güvenlik Açığı</h3><p>Teknik açıklar kadar önemli bir başka konu da sosyal mühendisliktir.</p><p>Siber güvenlikte en zayıf halka çoğu zaman insandır.</p><ul><li>Zayıf parolalar</li><li>Phishing e-postalarına tıklama</li><li>Yetkisiz erişim paylaşımı</li></ul><p>En gelişmiş sistem bile, bilinçsiz bir kullanıcı nedeniyle risk altına girebilir.</p><p>Bu yüzden etik hacker’lık yalnızca teknik değil, davranışsal güvenliği de kapsar.</p><h3>Gerçek Dünya Perspektifi</h3><p>Bugün veri ihlalleri milyarlarca dolarlık zarara yol açıyor. Bir şirket için güvenlik açığı:</p><ul><li>Finansal kayıp</li><li>Hukuki yaptırım</li><li>Marka itibarının zedelenmesi</li></ul><p>anlamına gelebilir.</p><p>Bu nedenle şirketler artık yalnızca yazılım geliştirici değil, güvenlik bilinci olan mühendisler arıyor.</p><h3>Etik Hacker’lık Film Sahnesi Değildir</h3><p>Popüler kültür hacker’ı dramatize eder. Oysa gerçek dünyada:</p><ul><li>Saatlerce log incelenir</li><li>Konfigürasyon dosyaları analiz edilir</li><li>Basit ama kritik hatalar bulunur</li></ul><p>Siber güvenlik çoğu zaman sabır, disiplin ve detaycılıktır.</p><p>Gerçek hacker zihniyeti şu soruyu sorar:</p><blockquote><em>“Bu sistem en zayıf nerede?”</em></blockquote><h3>Her Yazılımcı Neden Güvenlik Bilmelidir?</h3><p>Siber güvenlik yalnızca güvenlik uzmanlarının alanı değildir.</p><p>Bir backend geliştirici:</p><ul><li>Input validation yapmazsa</li><li>Yetkilendirme kontrolünü atlarsa</li><li>Hassas veriyi düz metin saklarsa</li></ul><p>potansiyel bir güvenlik açığı oluşturur.</p><p>Güvenli yazılım geliştirme artık temel mühendislik sorumluluğudur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yE5ulMfwFe4bfXqxes-7VQ.png" /></figure><h3>Sonuç</h3><p>Dijital dünya büyüdükçe saldırı yüzeyi de büyüyor. Kod satırları arttıkça, entegrasyonlar çoğaldıkça ve sistemler karmaşıklaştıkça güvenlik artık bir “sonradan eklenen özellik” değil; tasarımın merkezinde olması gereken bir prensip haline geliyor.</p><p>Etik hacker’lık tam olarak bu bilinçle var olur. Amaç sistemi utandırmak değil, güçlendirmektir. Amaç açık yakalamak değil, riskleri görünür kılmaktır.</p><p>Gerçek güvenlik, hiçbir açığın olmadığı bir sistem kurmak değildir.<br>Gerçek güvenlik, açıkların var olabileceğini kabul edip onları sürekli arayan bir zihniyete sahip olmaktır.</p><p>Çünkü dijital çağda en büyük tehdit saldırıların kendisi değil, “bize bir şey olmaz” düşüncesidir.</p><p>Ve güvenliğin başladığı yer, tam da bu düşüncenin sona erdiği noktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*_oQMxHLk_lKzaD7p20Eqlg.jpeg" /></figure><h3>Referanslar</h3><ul><li><a href="https://medium.com/@mertcangoksudev/etik-hackleme-kavramlar%C4%B1-bd57cf2d2023">Etik Hackleme Kavramları</a></li><li><a href="https://medium.com/@attilla453/hacker-etik-anlay%C4%B1%C5%9F%C4%B1-gri-b%C3%B6lgelerde-do%C4%9Fruyu-bulmak-f7584b53283e">Hacker Etik Anlayışı: Gri Bölgelerde Doğruyu Bulmak</a></li><li><a href="https://medium.com/@zehragunduz001/gelece%C4%9Fi-%C5%9Fekillendiren-hayaller-bilgi-teknolojileri-siber-g%C3%BCvenlik-ve-etik-hacker-olmak-b5e8f35c55eb">Geleceği Şekillendiren Hayaller: Bilgi Teknolojileri, Siber Güvenlik ve Etik Hacker Olmak</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20419b1df205" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Factory Design Pattern ve Nesne Üretiminin Mimari Yönetimi]]></title>
            <link>https://medium.com/@hsdinonu/factory-design-pattern-ve-nesne-%C3%BCretiminin-mimari-y%C3%B6netimi-62c15ada60e6?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/62c15ada60e6</guid>
            <category><![CDATA[jvm-memory]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[factory-pattern]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 19:15:01 GMT</pubDate>
            <atom:updated>2026-02-25T19:16:06.091Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P3qQzqamciqooQUljJI-9w.png" /><figcaption><a href="https://gemini.google.com/">Görsel Referansı</a></figcaption></figure><h4>Giriş</h4><p>Günümüz yazılım projeleri büyüdükçe, kodun yalnızca çalışması değil; <strong>okunabilir, sürdürülebilir ve değişime açık</strong> olması da kritik hâle gelmiştir. Bu noktada karşılaşılan en temel problemlerden biri, nesnelerin nasıl ve nerede oluşturulması gerektiğidir. Yanlış yerde yapılan nesne üretimi, zamanla sıkı bağımlılıklar, karmaşık koşul yapıları ve yönetilmesi zor bir mimari ortaya çıkarabilir.</p><p>Bu yazıda, nesne oluşturma problemini ele alan <strong>Factory Design Pattern</strong>’in arkasındaki temel motivasyonu inceleyeceğiz. Öncelikle Factory Pattern kullanılmadan önce ortaya çıkan yapısal sorunları ele alacak, ardından bu pattern’in nesne üretimini nasıl merkezileştirdiğini ve kodun sorumluluklarını nasıl ayrıştırdığını adım adım değerlendireceğiz. Tüm anlatım, Java dilinde hazırlanmış basit bir ödeme sistemi örneği üzerinden ilerleyecek ve teorik kavramlar pratik kodlarla desteklenecektir.</p><p>Amaç, Factory Design Pattern’i yalnızca “nasıl uygulanır” sorusuyla değil; <strong>neden ihtiyaç duyulur, hangi problemleri çözer ve hangi durumlarda tercih edilmemelidir</strong> gibi sorular üzerinden bütüncül bir bakış açısıyla ele almaktır.</p><h4>Nesne Oluşturma Problemi Nerede Başlar?</h4><p>Çoğu yazılım projesinde nesneler, ihtiyaç duyulduğu anda ve doğrudan new anahtar kelimesi kullanılarak oluşturulur. Bu yaklaşım küçük ve sınırlı kapsamlı projelerde genellikle bir sorun teşkil etmez. Ancak sistem büyüdükçe ve farklı türde nesnelerin koşullara göre seçilmesi gerektiğinde, bu basit yaklaşım mimari problemlerin başlangıç noktası hâline gelir.</p><p>Özellikle servis katmanında, iş akışını yöneten sınıfların hangi nesnenin hangi koşulda oluşturulacağını bilmesi beklenir. Bu durum, if-else veya switch gibi koşul yapılarının giderek artmasına ve nesne oluşturma mantığının iş mantığıyla iç içe geçmesine neden olur. Zamanla bu sınıflar, yalnızca kendi sorumluluklarını yerine getiren yapılar olmaktan çıkar; sistemdeki farklı nesne türlerini tanıyan ve yöneten merkezî noktalar hâline gelir.</p><p>Bu yaklaşımın en önemli sonucu, sınıflar arası bağımlılığın artmasıdır. Bir sınıfın somut bir sınıfa doğrudan bağımlı olması, o sınıfta yapılacak en küçük değişikliğin bile zincirleme etkiler oluşturmasına yol açabilir. Yeni bir nesne türünün eklenmesi, mevcut kodun değiştirilmesini zorunlu kılar ve bu durum yazılımın değişime karşı kırılgan bir yapıya bürünmesine neden olur.</p><p>Bir diğer problem ise sorumlulukların net bir şekilde ayrıştırılamamasıdır. İş akışını yöneten bir sınıfın aynı zamanda nesne oluşturma sorumluluğunu da üstlenmesi, Single Responsibility Principle gibi temel tasarım ilkelerinin ihlal edilmesine yol açar. Kod çalışıyor olsa bile, mimari açıdan sürdürülebilirliği sorgulanır hâle gelir.</p><p>Ancak mesele yalnızca mimari değildir. Java’da her new anahtar kelimesi kullanıldığında JVM heap alanında yeni bir bellek tahsis edilir. Küçük ölçekli uygulamalarda bu durum çoğunlukla göz ardı edilebilir; ancak yüksek trafikli ve büyük sistemlerde kontrolsüz nesne üretimi heap kullanımını artırabilir. Yoğun nesne oluşturma, Garbage Collector’ın daha sık çalışmasına neden olabilir ve bu da performans dalgalanmalarına yol açabilir. Aşırı durumlarda heap alanının dolması OutOfMemoryError ile sonuçlanabilir.</p><p>Elbette Factory Design Pattern doğrudan bir bellek optimizasyon aracı değildir. Ancak nesne üretimini merkezi bir noktaya taşıyarak gerektiğinde caching, reuse veya farklı üretim stratejilerinin uygulanabilmesine imkân tanır. Böylece hem mimari hem de çalışma zamanı açısından daha kontrollü bir yapı elde edilir.</p><p>Bu noktada karşımıza çıkan temel soru şudur:<br>Bir nesnenin ne zaman ve nasıl oluşturulacağına kim karar vermelidir?</p><p>Factory Design Pattern, tam olarak bu soruya verilen yapısal bir cevaptır.</p><h4>Factory Pattern Olmadan Bir Örnek</h4><p>Nesne oluşturma problemini daha somut hâle getirmek için basit bir ödeme sistemi üzerinden ilerleyelim. Bu örnekte, farklı ödeme yöntemlerine göre farklı nesnelerin oluşturulması gereken bir senaryo ele alınmaktadır. İlk yaklaşımda, ödeme türüne göre hangi nesnenin kullanılacağına karar verme sorumluluğu doğrudan servis katmanına verilmiştir.</p><p>Aşağıdaki kod parçası, bu yaklaşımın tipik bir örneğini göstermektedir:</p><pre>public class PaymentService {<br>  public void pay(String method) {<br>        if (&quot;creditCard&quot;.equals(method)) {<br>            CreditCardPayment payment = new CreditCardPayment();<br>            payment.pay();<br>        } else if (&quot;cash&quot;.equals(method)) {<br>            CashPayment payment = new CashPayment();<br>            payment.pay();<br>        }<br>    }<br>}</pre><p>Bu yapı ilk bakışta basit ve anlaşılır görünse de, servis sınıfının birden fazla sorumluluğu üstlendiği dikkat çekmektedir. PaymentServiceyalnızca ödeme işlemini başlatmakla kalmamakta; aynı zamanda hangi ödeme nesnesinin oluşturulacağına da karar vermektedir. Bu durum, servis katmanının somut sınıflara doğrudan bağımlı hâle gelmesine yol açmaktadır.</p><p>Zamanla sisteme yeni bir ödeme yönteminin eklenmesi gerektiğinde, bu sınıfın değiştirilmesi kaçınılmaz olacaktır. Her yeni ödeme türü, mevcut if-else yapısının genişlemesine neden olur ve bu da kodun okunabilirliğini ve bakımını zorlaştırır. Dahası, iş akışını yöneten bir sınıfın nesne oluşturma detaylarını bilmesi, sorumlulukların net bir şekilde ayrıştırılmasını engeller.</p><p>Bu örnek, nesne oluşturma mantığının kontrolsüz bir şekilde yayılmasının, küçük bir kod parçasında bile nasıl mimari sorunlara yol açabileceğini açıkça göstermektedir. Factory Design Pattern, tam da bu noktada devreye girerek nesne üretim sorumluluğunu servis katmanından ayırmayı amaçlar.</p><h4>Ödeme Yöntemleri Arttığında Ortaya Çıkan Yapı</h4><p>Yukarıdaki değerlendirme, yalnızca iki ödeme yöntemi bulunan basit bir senaryo üzerinden yapılmıştır. Ancak gerçek dünya uygulamalarında ödeme sistemleri zamanla genişler ve kullanıcıya farklı ödeme seçenekleri sunmak zorunda kalır. Kredi kartı ve nakit ödemeye ek olarak; banka havalesi, üçüncü parti ödeme servisleri veya kripto para gibi yeni yöntemler sisteme dâhil edilebilir.</p><p>Bu durumda, nesne oluşturma sorumluluğunun servis katmanında tutulduğu yaklaşım hızla ölçeklenemez hâle gelir. Her yeni ödeme yöntemi, servis sınıfına yeni bir koşul eklenmesini zorunlu kılar ve if-else yapısı giderek büyür. Aşağıdaki kod parçası, yalnızca ödeme yöntemlerinin arttığı bir senaryoda servis katmanının nasıl şiştiğini açıkça göstermektedir:</p><pre>public class PaymentService {<br>  public void pay(String method) {<br>        if (&quot;creditCard&quot;.equals(method)) {<br>            CreditCardPayment payment = new CreditCardPayment();<br>            payment.pay();<br>        } else if (&quot;cash&quot;.equals(method)) {<br>            CashPayment payment = new CashPayment();<br>            payment.pay();<br>        } else if (&quot;bankTransfer&quot;.equals(method)) {<br>            BankTransferPayment payment = new BankTransferPayment();<br>            payment.pay();<br>        } else if (&quot;paypal&quot;.equals(method)) {<br>            PaypalPayment payment = new PaypalPayment();<br>            payment.pay();<br>        } else if (&quot;crypto&quot;.equals(method)) {<br>            CryptoPayment payment = new CryptoPayment();<br>            payment.pay();<br>        } else {<br>            throw new IllegalArgumentException(&quot;Geçersiz ödeme yöntemi&quot;);<br>        }<br>    }<br>}</pre><p>Bu örnek, servis katmanının yalnızca iş akışını yöneten bir yapı olmaktan çıkarak, sistemdeki tüm ödeme türlerini bilen ve yöneten merkezi bir bileşene dönüştüğünü göstermektedir. Yeni bir ödeme yönteminin eklenmesi, mevcut kodun değiştirilmesini kaçınılmaz kılmakta ve bu durum yazılımın <strong>değişime kapalı</strong> bir hâl almasına neden olmaktadır.</p><p>Bu noktada asıl problem, ödeme işleminin kendisinden ziyade, <strong>nesne oluşturma ve seçim sorumluluğunun yanlış yerde konumlandırılmış olmasıdır</strong>. Factory Design Pattern, tam olarak bu sorumluluğu servis katmanından ayırarak daha sürdürülebilir bir mimari sunmayı hedefler.</p><h4>Factory Design Pattern Nedir?</h4><p>Factory Design Pattern, tam olarak bu sorumluluğu servis katmanından ayırarak daha sürdürülebilir bir mimari sunmayı hedefler. Nesne oluşturma sürecinin merkezi bir yapı üzerinden yönetilmesi, iş akışını yöneten sınıfların somut implementasyonlara olan bağımlılığını ortadan kaldırır. Bu sayede kod daha okunabilir, test edilebilir ve değişime daha açık bir hâl alır.</p><h4>Factory Pattern ile Çözüm</h4><p>Factory Design Pattern’in uygulanabilmesi için ilk adım, servis katmanının doğrudan bağımlı olduğu somut sınıflardan ayrıştırılmasıdır. Bunun için öncelikle farklı ödeme türlerinin ortak bir davranış altında toplanması gerekir. Bu ortak davranış, bir soyutlama aracılığıyla tanımlanır.</p><pre>public interface Payment {<br>    void pay();<br>}</pre><p>Bu arayüz, ödeme işleminin <em>nasıl</em> gerçekleştirildiğini değil, yalnızca <em>ne yapılacağını</em> tanımlar. Böylece servis katmanı, somut ödeme sınıflarını bilmeden bu arayüz üzerinden işlem yapabilir.</p><p>Ardından, her bir ödeme yöntemi bu arayüzü gerçekleştiren ayrı sınıflar hâline getirilir:</p><pre>public class CreditCardPayment implements Payment {<br>    public void pay() {<br>        System.out.println(&quot;Credit card payment processed&quot;);<br>    }<br>}</pre><pre>public class CashPayment implements Payment {<br>    public void pay() {<br>        System.out.println(&quot;Cash payment processed&quot;);<br>    }<br>}</pre><p>Bu noktaya kadar yapılan işlem, nesne türlerini ortak bir soyutlama altında toplamaktır. Ancak nesnelerin <strong>nerede ve nasıl oluşturulacağı</strong> sorusu hâlâ cevapsızdır. Factory Design Pattern, tam olarak bu sorumluluğu üstlenen yapıyı tanımlar.</p><h4>Nesne Üretimini Merkezileştirmek: PaymentFactory</h4><p>Factory Design Pattern’in temel amacı, nesne üretim sürecini merkezi bir noktada toplamak ve bu sorumluluğu servis katmanından ayırmaktır. Bu doğrultuda, ödeme nesnelerinin hangi koşulda ve hangi sınıftan oluşturulacağı bilgisi ayrı bir yapı içerisine taşınır. Bu yapı, Factory olarak adlandırılır.</p><pre>public class PaymentFactory {<br>  public static Payment create(PaymentType type) {<br>        switch (type) {<br>            case CREDIT_CARD:<br>                return new CreditCardPayment();<br>            case CASH:<br>                return new CashPayment();<br>            case BANK_TRANSFER:<br>                return new BankTransferPayment();<br>            case PAYPAL:<br>                return new PaypalPayment();<br>            case CRYPTO:<br>                return new CryptoPayment();<br>            default:<br>                throw new IllegalArgumentException(&quot;Geçersiz ödeme yöntemi&quot;);<br>        }<br>    }<br>}</pre><p>Bu yapı sayesinde, ödeme nesnelerinin oluşturulmasına ilişkin tüm karar mekanizması tek bir sınıf altında toplanmıştır. Servis katmanı artık somut sınıfları tanımak zorunda değildir; yalnızca ihtiyaç duyduğu nesneyi Factory aracılığıyla talep eder. Böylece nesne üretimiyle ilgili değişiklikler, sistemin geri kalanını etkilemeden yönetilebilir hâle gelir.</p><h4>String Karşılaştırması Yerine Enum Kullanımı</h4><p>Yukarıdaki örnekte ödeme yöntemi String parametresi üzerinden belirlenmiştir. Ancak gerçek dünya projelerinde “magic string” kullanımı hataya açıktır ve tip güvenliği sağlamaz. Küçük bir yazım hatası bile sistemin yanlış davranmasına neden olabilir ve bu tür hatalar genellikle ancak çalışma zamanında fark edilir.</p><p>Daha güvenli ve sürdürülebilir bir yaklaşım, ödeme türlerini bir enum ile modellemektir:</p><pre>public enum PaymentType {<br>    CREDIT_CARD,<br>    CASH,<br>    BANK_TRANSFER,<br>    PAYPAL,<br>    CRYPTO<br>}</pre><h4>Servis Katmanının Sadeleşmesi</h4><p>Nesne üretim sorumluluğu Factory sınıfına taşındıktan sonra, servis katmanı yalnızca kendi asli görevine odaklanır: iş akışını yönetmek. Önceki örneklerde yer alan koşul yapıları ve somut sınıf bağımlılıkları, servis katmanından tamamen kaldırılmıştır.</p><pre>public class PaymentService {<br>  public void pay(PaymentType type) {<br>        Payment payment = PaymentFactory.create(type);<br>        payment.pay();<br>    }<br>}</pre><p>Bu hâliyle PaymentService, ödeme işleminin nasıl gerçekleştirildiğini ya da hangi sınıfın kullanıldığını bilmez. Tek yaptığı şey, kendisine verilen parametre doğrultusunda uygun bir ödeme davranışını çalıştırmaktır. Bu yaklaşım, servis katmanının <strong>daha okunabilir, daha test edilebilir ve daha sürdürülebilir</strong> bir yapıya kavuşmasını sağlar.</p><h4>Önce ve Sonra: Mimari Etki</h4><p>Factory Design Pattern uygulanmadan önce, servis katmanı hem iş akışını hem de nesne oluşturma sürecini yönetmekteydi. Bu durum, sınıfların birden fazla sorumluluk üstlenmesine ve somut implementasyonlara sıkı sıkıya bağlanmasına neden olmaktaydı. Factory Pattern ile birlikte bu sorumluluklar ayrıştırılmış ve bağımlılıklar soyutlamalar üzerinden yönetilir hâle gelmiştir.</p><p>Bu değişim, yalnızca kodun kısalmasını değil; aynı zamanda sistemin yeni gereksinimlere daha kolay adapte olabilmesini de mümkün kılar. Yeni bir ödeme yöntemi eklendiğinde, servis katmanında herhangi bir değişiklik yapılmasına gerek kalmaz; yalnızca Factory’nin genişletilmesi yeterlidir.</p><h4>Factory Pattern Her Zaman Doğru Çözüm mü?</h4><p>Factory Design Pattern güçlü bir mimari araç olsa da, her senaryo için uygun değildir. Eğer sistemde yalnızca tek bir nesne türü varsa veya nesne üretim süreci basitse, Factory kullanımı gereksiz bir soyutlama katmanı oluşturabilir. Bu nedenle Factory Pattern, özellikle <strong>nesne türlerinin zamanla artmasının beklendiği ve bu türlerin koşullara göre seçildiği</strong> senaryolarda tercih edilmelidir.</p><h4>Sonuç</h4><p>Factory Design Pattern, nesne oluşturma sorumluluğunu doğru katmana taşıyarak yazılım mimarisinin sadeleşmesini sağlar. Doğru bağlamda kullanıldığında, kodun okunabilirliğini artırır, bağımlılıkları azaltır ve sistemin uzun vadede sürdürülebilir olmasına katkı sunar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lW7_blc8yhR0zlfY9my-mg.jpeg" /></figure><h3>Referanslar</h3><ul><li><a href="https://www.geeksforgeeks.org/system-design/factory-method-for-designing-pattern/">Factory method Design Pattern - GeeksforGeeks</a></li><li><a href="https://www.javaturk.org/tasarim-kaliplari-factory-method-uretici-metot-i/">Tasarım Kalıpları: Factory Method (Üretici Metot) - I - Java Günlüğüm</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62c15ada60e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot ile Prometheus + Grafana: Uçtan Uca Observability]]></title>
            <link>https://medium.com/@hsdinonu/spring-boot-ile-prometheus-grafana-u%C3%A7tan-uca-observability-b4b88d968d75?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4b88d968d75</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[grafana]]></category>
            <category><![CDATA[prometheus]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 13:13:29 GMT</pubDate>
            <atom:updated>2026-02-19T13:16:31.902Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wXoTUUPkMZCIn-Y2OhGzXQ.png" /><figcaption><a href="http://cursor.com/">Görsel Referansı</a></figcaption></figure><h3>Giriş</h3><p>Uygulamanız çalışıyor — peki gerçekten <em>ne</em> yaptığını biliyor musunuz? Hangi endpoint’ler en çok çağrılıyor, yanıt süreleri nasıl, sistem sağlıklı mı? Bu sorulara cevap vermek için metrikleri toplamak ve görselleştirmek gerekiyor. Bu yazıda, bir Spring Boot uygulamasını <strong>Prometheus</strong> ve <strong>Grafana</strong> ile nasıl izleyeceğinizi, tek komutla <strong>Docker Compose</strong> üzerinden nasıl ayağa kaldıracağınızı adım adım anlatıyorum.</p><h4>Neden Prometheus ve Grafana?</h4><p><strong>Prometheus</strong>, zaman serisi metriklerini toplayan, saklayan ve sorgulayan açık kaynak bir sistemdir. Pull modeli kullanır: hedef uygulamalara belirli aralıklarla istek atar ve metrik endpoint’lerinden veriyi çeker. <strong>Grafana</strong> ise bu veriyi dashboard’lar ve grafiklerle görselleştirir. İkisi birlikte, uygulamanızın davranışını ölçmenizi ve anlamanızı sağlar.</p><p>Bu projede:</p><ul><li>Spring Boot <strong>Actuator</strong> + <strong>Micrometer</strong> ile uygulama metrikleri Prometheus formatında sunuluyor.</li><li><strong>Docker Compose</strong> ile uygulama, Prometheus ve Grafana tek komutla çalışıyor.</li><li>Özel metrikler (istek sayısı, yanıt süreleri) kod içinde tanımlanıyor ve dashboard’da kullanılıyor.</li></ul><h4>Mimari: Veri Nasıl Akıyor?</h4><p>Aşağıdaki diyagram, sistemin nasıl çalıştığını özetliyor:</p><p>Mimari: Spring Boot → Prometheus → Grafana</p><p><strong>Akış:</strong></p><ol><li><strong>Spring Boot uygulaması</strong> (demo-app), /actuator/prometheus endpoint’i üzerinden metrikleri açığa çıkarır (Counter, Timer, JVM, HTTP vb.).</li><li><strong>Prometheus</strong>, yapılandırmadaki hedefleri periyodik olarak (ör. 10 saniyede bir) scrape eder ve veriyi kendi veritabanında saklar.</li><li><strong>Grafana</strong>, Prometheus’u veri kaynağı olarak kullanır; dashboard’lardaki panel sorguları PromQL ile Prometheus’a gider ve sonuçlar grafiklere dönüşür.</li></ol><p>Hepsi aynı Docker ağında olduğu için birbirlerine isim üzerinden (örn. demo-app:8080, prometheus:9090) erişir.</p><h4>Proje Yapısı</h4><pre>demo/<br>├── docker-compose.yml          # Uygulama + Prometheus + Grafana<br>├── Dockerfile                  # Çok aşamalı Spring Boot imajı<br>├── prometheus/<br>│   └── prometheus.yml          # Scrape hedefleri (demo-app)<br>├── grafana/<br>│   └── provisioning/           # Datasource + dashboard otomatik yükleme<br>│       ├── datasources/<br>│       └── dashboards/<br>└── src/main/java/.../controller/<br>    └── HelloController.java    # Örnek API + özel metrikler</pre><ul><li><strong>docker-compose.yml</strong>: Üç servisi tek ağda tanımlar; Prometheus ve Grafana, uygulama imajına bağımlıdır.</li><li><strong>prometheus.yml</strong>: demo-app:8080 için metrics_path: /actuator/prometheus ve scrape aralığı tanımlıdır.</li><li><strong>Grafana provisioning</strong>: Açılışta Prometheus datasource ve hazır bir “Demo Uygulama Metrikleri” dashboard’u yüklenir.</li></ul><h4>Uygulama Tarafı: Metrikleri Nasıl Üretiyoruz?</h4><p>Spring Boot’ta metrikler <strong>Micrometer</strong> ile üretilir. Actuator’ı açtığınızda JVM, HTTP, log vb. metrikleri otomatik gelir; biz ek olarak <strong>özel metrikler</strong> ekliyoruz.</p><h4>Actuator ve Prometheus Açılımı</h4><p>application.properties içinde:</p><pre>management.endpoints.web.exposure.include=health,info,prometheus,metrics<br>management.metrics.export.prometheus.enabled=true</pre><p>Böylece /actuator/prometheus endpoint’i açılır ve Prometheus’un beklediği formatta metrikler sunulur.</p><h4>Özel Metrikler: Counter ve Timer</h4><p>HelloController içinde iki tür metrik kullanılıyor:</p><ul><li><strong>Counter</strong> (demo_hello_requests_total): Toplam istek sayısı — her çağrıda artar.</li><li><strong>Timer</strong> (demo_hello_duration_seconds, demo_slow_duration_seconds): Yanıt sürelerini kaydeder; Prometheus’ta _count, _sum ile gelir, ortalama süre rate(sum)/rate(count) ile hesaplanır.</li></ul><p>Örnek kod (kısaltılmış):</p><pre>public HelloController(MeterRegistry registry) {<br>    this.requestCounter = Counter.builder(&quot;demo.hello.requests&quot;)<br>            .description(&quot;Toplam hello istek sayısı&quot;)<br>            .register(registry);<br>    this.helloTimer = Timer.builder(&quot;demo.hello.duration&quot;)<br>            .description(&quot;Hello endpoint yanıt süresi&quot;)<br>            .register(registry);<br>    // ...<br>}</pre><pre>@GetMapping(&quot;/hello&quot;)<br>@Timed(value = &quot;demo.hello&quot;, description = &quot;Hello endpoint&quot;)<br>public ResponseEntity&lt;Map&lt;String, String&gt;&gt; hello() {<br>    return helloTimer.record(() -&gt; {<br>        requestCounter.increment();<br>        return ResponseEntity.ok(Map.of(&quot;message&quot;, &quot;Merhaba! ...&quot;, &quot;status&quot;, &quot;ok&quot;));<br>    });<br>}</pre><ul><li><strong>/api/hello</strong>: Hızlı yanıt; hem counter hem timer ölçülür.</li><li><strong>/api/slow</strong>: Kasıtlı 500–1500 ms gecikme; yanıt süresi demo_slow_duration_seconds ile izlenir.</li></ul><p>Bu metrikler /actuator/prometheus çıktısında demo_hello_requests_total, demo_hello_duration_seconds_*, demo_slow_duration_seconds_* olarak görünür.</p><h3>Çalıştırma ve Erişim</h3><h4>Docker Compose ile (Önerilen)</h4><p>Tüm stack’i ayağa kaldırmak için:</p><pre>docker compose up -d --build</pre><pre>| Bileşen    | URL                      | Açıklama                          |<br>|-----------|---------------------------|-----------------------------------|<br>| Uygulama  | <a href="http://localhost:8080/">http://localhost:8080</a>     | API + Actuator                    |<br>| Prometheus| <a href="http://localhost:9090/">http://localhost:9090</a>     | Sorgu arayüzü, Targets, Graph     |<br>| Grafana   | <a href="http://localhost:3000/">http://localhost:3000</a>     | Dashboard (varsayılan: admin/admin) |</pre><h4>Sadece Uygulamayı Lokal Çalıştırmak</h4><p>Prometheus ve Grafana’yı Docker’da bırakıp sadece uygulamayı IDE veya terminalden çalıştırabilirsiniz. Bu durumda Prometheus’un uygulamaya erişebilmesi için prometheus.yml içinde hedefi host.docker.internal:8080 (Mac/Windows) veya host IP’nize göre güncellemeniz gerekir.</p><pre>./mvnw spring-boot:run</pre><h4>Prometheus’ta Hangi Metriklere Bakmalı?</h4><p><a href="http://localhost:9090/"><strong>http://localhost:9090</strong></a> → <strong>Graph</strong> / <strong>Explore</strong> bölümünde aşağıdaki sorguları kullanabilirsiniz:</p><pre>| Amaç                         | PromQL (örnek) |<br>|-----------------------------|-----------------|<br>| Toplam hello istek sayısı   | `demo_hello_requests_total` |<br>| Hello ortalama yanıt süresi | `rate(demo_hello_duration_seconds_sum[5m]) / rate(demo_hello_duration_seconds_count[5m])` |<br>| Slow ortalama süre (ms)     | `rate(demo_slow_duration_seconds_sum[5m]) / rate(demo_slow_duration_seconds_count[5m]) * 1000` |<br>| Dakikada istek hızı         | `rate(demo_hello_requests_total[5m]) * 60` |<br>| Uygulama ayakta mı?        | `up{job=&quot;demo-app&quot;}` |</pre><p><strong>Targets</strong> sayfasında (Status → Targets) demo-app job’ının <strong>UP</strong> görünmesi gerekir. Aşağıda her iki hedefin de (demo-app ve prometheus) sağlıklı göründüğü örnek bir ekran görüntüsü yer alıyor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dSW-PcjEp9fTHmPSx0ut4A.jpeg" /><figcaption>Prometheus Status</figcaption></figure><h4>Grafana’da Ne Göreceksiniz?</h4><p>Grafana’da (admin / admin) <strong>Dashboards</strong> menüsünden <strong>“Demo Uygulama Metrikleri”</strong> dashboard’unu açın. Bu dashboard’ta:</p><ul><li><strong>İstek hızı</strong>: Dakikada gelen istek sayısı (rate).</li><li><strong>Yanıt süreleri</strong>: Hello ve Slow endpoint’leri için ortalama yanıt süreleri (ms).</li><li><strong>Toplam Hello istekleri</strong>: demo_hello_requests_total toplamı.</li><li><strong>Demo App durumu</strong>: up{job=&quot;demo-app&quot;} (1 = ayakta).</li></ul><p>Birkaç kez GET http://localhost:8080/api/hello ve GET http://localhost:8080/api/slow çağırıp birkaç dakika bekledikten sonra grafiklerin dolduğunu görmelisiniz. Örnek bir dashboard görünümü:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lxTj8xycVEKYXl7hCGi3Dg.jpeg" /><figcaption>Grafana Dashboard</figcaption></figure><h4>Sonuç</h4><ul><li><strong>Spring Boot Actuator + Micrometer</strong> ile Prometheus formatında metrik üretiyoruz; özel Counter ve Timer ekleyerek iş metriklerinizi de izleyebilirsiniz.</li><li><strong>Prometheus</strong> bu metrikleri periyodik scrape ile topluyor; <strong>Grafana</strong> ile dashboard’larda görselleştiriyoruz.</li><li><strong>Docker Compose</strong> ile üç bileşen tek komutla çalışıyor; mimari net, tekrarlanabilir ve makalenizde anlattığınız senaryoyla bire bir uyumlu.</li></ul><p>Bu yapıyı kendi projenize uyarlarken yeni endpoint’ler için benzer şekilde MeterRegistry kullanarak Counter/Timer ekleyebilir, Prometheus’a yeni job’lar ve Grafana’ya yeni panel sorguları ekleyebilirsiniz. İyi ölçümler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*reJOBwi-x3ZQsgxjbhS7wg.jpeg" /></figure><h4>Referanslar</h4><ul><li><a href="https://micrometer.io/docs">Micrometer Application Observability</a></li><li><a href="https://prometheus.io/docs/introduction/overview/">Overview | Prometheus</a></li><li><a href="https://prometheus.io/docs/prometheus/latest/querying/basics/">Querying basics | Prometheus</a></li><li><a href="https://grafana.com/docs/grafana/latest/">Grafana OSS and Enterprise | Grafana documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4b88d968d75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Derin Öğrenme (Deep Learning) Nedir? Nasıl Öğrenir?]]></title>
            <link>https://medium.com/@hsdinonu/derin-%C3%B6%C4%9Frenme-deep-learning-nedir-nas%C4%B1l-%C3%B6%C4%9Frenir-cd8c30682dff?source=rss-faf29e12ba4c------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd8c30682dff</guid>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[HSD İnönü Üniversitesi]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 12:42:32 GMT</pubDate>
            <atom:updated>2026-01-27T12:42:32.222Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/963/0*gadxL_0jFfXeuLIk.png" /><figcaption><a href="https://gemini.google.com/">Görsel Referansı</a></figcaption></figure><h3>Giriş</h3><p>Günümüzde yapay zeka teknolojileri oldukça gelişmiş ve hayatımızın her alanına entegre olmuş durumda. Bu hızlı gelişimle birlikte birçok kavram ortaya çıkmıştır. Şüphesiz bu kavramlardan birisi de <strong>Derin Öğrenme’</strong>dir.</p><p>Bu yazıda, derin öğrenme mimarisinin temel mantığını,<strong> sinir ağlarının</strong> veriden nasıl anlam çıkardığını ve bu öğrenme süreçlerinin teknik arka planını inceleceğiz. Ayrıca <strong>yapay zeka ve makine öğrenmesi </strong>ekosistemi içerisinde derin öğrenmenin nasıl bir alt küme oluşturduğunu ve bu kavramlar arasında nasıl bir hiyerarşi olduğunu ele alacağız.</p><h3>1. Deep Learning (Derin Öğrenme) Kavramı</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/321/0*50Oeg3PB_r5kEmUh.png" /></figure><p>Derin öğrenme; büyük veri kümelerinden öğrenme yeteneğine sahip, <strong>yapay sinir ağlarını (ANN)</strong> kullanan bir makine öğrenimi dalıdır. Derin öğrenmenin makine öğrenmesinden temel farkları; öğrenme yöntemleri ve görev karmaşıklığıdır.<br><strong>Yapay Zeka</strong> ise bu hiyerarşinin en tepesinde yer alan, insan zekasını taklit eden sistemlerin genel adıdır.<strong> Makine öğrenmesi </strong>yapay zekanın bir alt kümesi, derin öğrenme ise makine öğrenmesinin daha özelleşmiş, katmanlı bir formudur. Bu yapıda derin öğrenme, özellikle <strong>görüntü işleme, doğal dil işleme, veri sınıflandırma ve otonom sürüş </strong>gibi yüksek işlem gücü gerektiren alanlarda devrim yaratmaktadır.</p><h3>1.1 Derin Öğrenme Ağının Bileşenleri</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/828/0*xkKY7L3iV1ss2_6K.png" /><figcaption><a href="https://dergipark.org.tr/tr/download/article-file/1571016">Görsel Referansı</a></figcaption></figure><p>Derin öğrenme mimarisi, <strong>katmanlardan</strong> oluşur ve her bir katman kendinden önceki katmandan gelen çıktıyı girdi olarak alır. Bunlar şunlardır:</p><ul><li><strong>Girdi Katmanı (Input Layer)</strong></li><li><strong>Gizli Katman (Hidden Layer)</strong></li><li><strong>Çıktı Katmanı (Output Layer)</strong></li></ul><ol><li><strong>Girdi Katmanı (Input Layer)<br></strong>Sistemin ilk aşamasıdır. <strong>Ham verilerin </strong>modele dahil edildiği bu katman; veri setindeki bağımsız her bir değişkeni ifade eden<em> </em><strong><em>“düğüm”</em></strong>lerden<strong><em> </em></strong>oluşur. Bu katmanda hiçbir matematiksel işlem uygulanmadan veri bir sonraki katmana iletilir.</li><li><strong>Gizli Katman (Hidden Layer)<br></strong>Gizli Katman, <strong>öğrenmenin</strong> gerçekleştiği katmandır. Bu katmanda bulunan düğüm sayısının bir sınırı bulunmamaktadır ancak bu sayının gereğinden fazla olması ya da az olması modelin <strong>aşırı öğrenmesine</strong> veya <strong>eksik öğrenmeye</strong> yol açabilir. Bu nedenle bu katmanın boyutu, modelin gerçeklediği probleme göre oluşturulmalıdır.</li><li><strong>Çıktı Katmanı(Output Layer)<br></strong>Modelin işlediği veriler sonucunda elde edilen nihai kararın veya <strong>tahminin</strong> üretildiği son katmandır. Bu katmandaki düğümlerin sayısı, modellenmek istenen problemin türüne göre belirlenir.</li></ol><h3>1.2 Derin Öğrenme Nasıl Öğrenir?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*O-HwKctG9uWzETtM9Q0XoQ.webp" /><figcaption><a href="https://www.geeksforgeeks.org/artificial-intelligence/artificial-neural-networks-and-its-applications/">Görsel Referansı</a></figcaption></figure><p>Derin öğrenme algoritmaları, insan beynindeki nöronlardan esinlenerek modellenen sinir ağı yapılarıdır. Örneğin, bir insan beyni bilgiyi öğrenmek ve faydalı çıkarımlar yapmak için milyonlarca birbirine bağlı <strong>“nöron”</strong> içerir. Benzer şekilde derin öğrenmede bu yapay sinir ağları ile gösterilir.</p><p>Derin öğrenmede <strong>“öğrenme”</strong> kavramı <strong><em>“parametrelerin güncellenmesi”</em></strong> denilebilir. Öğrenmenin <strong>“Hidden Layer”</strong> katmanın da olduğunu biliyoruz, bu katmandaki her bir <strong><em>‘nöron’</em></strong> ,bir başka deyişle <strong><em>‘düğüm’</em></strong> , aşağıdaki matematiksel formül ile gösterilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/158/0*ABk4uxHp0CJAIPUT.png" /></figure><p>Bu denklemdeki parametreler;<br>•<strong> W (weight):</strong> ağırlık matrisi<br>• <strong>b:</strong> Bias(sapma) terimi<br>• <strong>h:</strong> her bir katmandaki nöronun çıktı değeri</p><p>Burada elde edilen her bir <strong>“h”</strong> değeri bir<strong> aktivasyon fonksiyonuna</strong> dahil edilir, elde edilen çıktı bir sonraki katmana girdi olarak iletilir. Bu işlem, toplam katman sayısına bağlı olarak tekrarlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/0*qLxJuUVkfklp1hcj.png" /><figcaption>Sinir Ağı Mimarisi Ve Öğrenme Süreci</figcaption></figure><p>Derin öğrenme sürecinde<strong> ‘öğrenme’ </strong>olgusu, verinin model içerisindeki yolculuğu üç temel aşamadan oluşur. Modelin ham veriyi işleyip kendini optimize etmesini sağlayan bu döngüsel aşamalar şunlardır:</p><ul><li><strong>Forward Propagation (İleri Yayılım)</strong></li><li><strong>Loss Calculation (Kayıp Hesaplama)</strong></li><li><strong>Backward Propagation (Geri Yayılım)</strong></li></ul><p><strong>1-Forward Propagation (İleri Yayılım)</strong></p><p>İleri yayılım (forward propagation) işlemi, temel olarak modelin çıktı veya <strong>“tahmin</strong>” üretme sürecidir. Bu süreçte her bir <strong>düğümün (nöronun)</strong> çıktısı bir <strong>aktivasyon fonksiyonundan</strong> geçirilir ve elde edilen değer bir sonraki gizli katmana girdi olarak iletilir. Bu işlemler, katman sayısına göre devam eder. Aşağıda iki gizli katmanı bulunan modelin ileri yayılım sürecinin ait matematiksel ifadeler yer almaktadır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/169/0*pzyT0byhaMJTEu8z.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/376/0*lYPkqNzXugjbNdSj.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/376/0*M6Pin0uwjTvtNuCe.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/132/0*n490yKaCPkO8Mm9_.png" /></figure><p><strong>Buradaki denklemlerde:</strong><br><strong>• ƒ :</strong> Aktivasyon fonksiyonu<br><strong>• y’: </strong>Output veya modelin ürettiği “tahmin” değeri</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0RMUvFXDEPyr3u8E" /></figure><p><strong>En Çok Kullanılan Bazı Aktivasyon Fonksiyonları:</strong></p><p><strong>• ReLU (Doğrultulmuş Doğrusal Birim):</strong>Negatif değerleri sıfırlayan, pozitif değerleri olduğu gibi bırakan fonksiyondur.<br><strong>•Sigmoid (σ):</strong> Değerleri 0 ile 1 arasına sıkıştıran lojistik fonksiyondur.<br><strong>• Hiperbolik Tanjant (tanh): </strong>Değerleri -1 ile 1 arasına sıkıştıran fonksiyondur.</p><p><strong>2</strong>-<strong>Loss Calculation (Kayıp Hesaplama)</strong></p><p>Bu aşamada, modelin üretmiş olduğu çıktı(y’) ile gerçek değer(y) karşılaştırılır ve bu işlem sonucunda bir hata değeri olan <strong>‘loss’ (kayıp) </strong>elde edilir. Bu karşılaştırma için <strong>Kayıp Fonksiyonu (Loss Function) </strong>kullanılır. Kayıp fonksiyonu, modellenmek istenen problemin türüne göre (Sınıflandırma veya Regresyon) belirlenir.</p><ul><li><strong>Sınıflandırma (Classification): </strong>Çıktının belirli kategorilere göre (Örneğin: Kedi/Köpek, Var/Yok) ayrıldığı problemlerdir. Bu problemlerde genellikle <strong>Kategorik Çapraz Entropi (Categorical Crossentropy)</strong> fonksiyonu kullanılır.</li><li><strong>Regresyon (Regression): </strong>Çıktının sürekli sayısal değerler (Örneğin: Fiyat tahmini, Sıcaklık tahmini) olduğu problemlerdir. Burada genellikle <strong>Ortalama Hata Karesi (Mean Squared Error) </strong>fonksiyonu kullanılır.</li></ul><p><strong>3-Backward Propagation (Geri Yayılım)</strong></p><p><strong>Geri yayılım(backward propagation)</strong> işleminde parametrelerin güncellenmesi aşaması tam da bu noktada gerçekleşir. Buradaki parametreler <strong>W(ağırlık)</strong> ve <strong>b(sapma/bias)</strong> terimleridir. Güncelleme işlemi için, kayıp fonksiyonundan elde edilen hata (loss) değeri bir<strong> optimizasyon algoritması (Optimizer)</strong> işlenerek yeni W ve b değerleri hesaplanır. Bu süreçte genellikle <strong>Gradyan İnişi (Gradient Descent) </strong>yöntemi kullanılarak hatayı minimuma indirecek parametreler bulunur.</p><ul><li><strong>Gradyan İnişi (Gradient Descent) Algoritması<br></strong>Bu algoritma w(ağırlık) parametresi için aşağıdaki gibi ifade edilebilir:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/206/0*Y2sI59_3p_8US_J4.png" /></figure><p>Bu denklemde;<br><strong>• L </strong>: Hata fonksiyonu<br>•<strong> l(learning rate/öğrenme oranı) :</strong> Bu parametre modelin ne kadar hızlı öğreneceğini belirler .<strong><br>• dL/dW : </strong>Hata fonksiyonun W(ağırlık) ye göre türevidir.</p><p><strong>dL/dW ‘nin Hesaplanması:<br></strong>Bu işlemde zincirleme türev alma kuralı uygulanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/388/0*S8SFuIxLaL8WxqZP.png" /></figure><p><strong>Buradaki denklemde :</strong><br><strong>• ƒ</strong> : n adet katmandaki aktivasyon fonksiyonun çıktısıdır.</p><p>Modelde yer alan<strong> b(bias/sapma)</strong> parametresi, <strong>W(ağırlık)</strong> parametresinin hesaplama süreciyle aynı yöntem izlenerek elde edilebilir.</p><h3>1.3 Derin Öğrenme Algoritmaları</h3><p>Derin Öğrenme (DL), temelini yapay sinir ağlarından alsa da günümüzde <strong>verinin yapısına ve problemin türüne </strong>göre özelleşmiş birçok farklı mimari ve algoritma bulunmaktadır. Bu kapsamda öne çıkan bazı algoritmalar şunlardır:</p><ul><li><strong>Evrişimsel Sinir Ağları (CNN)</strong></li><li><strong>Yinelemeli Sinir Ağları (RNN)</strong></li><li><strong>Uzun Kısa Süreli Bellek (LSTM)</strong></li><li><strong>Çekişmeli Üretici Ağlar (GANs)</strong></li><li><strong>Radyal Temelli Fonksiyon Ağları (RBFN)</strong></li><li><strong>Kendini Düzenleyen Haritalar (SOM)</strong></li><li><strong>Derin İnanç Ağları (DBNs)</strong></li><li><strong>Otomatik Kodlayıcılar (Autoencoders)</strong></li><li><strong>Artık Ağlar (ResNet</strong>)</li><li><strong>Transformes</strong></li></ul><p>Bu algoritmaların temel mantığı; veriyi katmanlar aracılığıyla hiyerarşik bir şekilde işleyerek, insan müdahalesine gerek duymadan <strong>tahmin</strong> yapmalarına dayanır. Bu algoritmaları birbirinden ayıran fark, <strong>verinin yapısına ve modellenmek istenen probleme özgü </strong>tasarlanmış olmalarıdır. Derin öğrenme algoritmaları, günümüzde otonom araçlardan tıbbi teşhislere, dilden dile çeviriden finansal risk analizlerine kadar geniş bir yelpazede görev üstlenmektedir.</p><h3>Sonuç</h3><p>Derin öğrenme, yapay zekanın geniş kapsamı içerisinde<strong> “Makine Öğrenmesi”</strong> ile başlayan veriden anlam çıkarma sürecini, çok katmanlı <strong>sinir ağları</strong> aracılığıyla daha ileri bir boyuta taşımıştır. <strong>Derin öğrenme,</strong> özellikle büyük veri setleri ve karmaşık örüntülerin çözümlenmesinde büyük avantaj sağlamaktadır.</p><p>Gelecekte, bu algoritmaların daha verimli hale gelmesi ve <strong>hesaplama maliyetlerinin optimize edilmesi,</strong> derin öğrenmenin sadece belirli endüstrilerdeki yerini değil, <strong>yapay zekanın</strong> gelecekteki konumunu da şekillendirecektir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0pDxyvbLEmPXHxfZuuCtog.jpeg" /></figure><h3>Referanslar</h3><ul><li><a href="https://medium.com/@mbodhija80/what-is-deep-learning-the-brain-behind-modern-ai-3c8782b12c82">What Is Deep Learning? The Brain Behind Modern AI</a></li><li><a href="https://bulutistan.com/blog/derin-ogrenme-nedir/?source=post_page-----233f97ea17f3---------------------------------------">Derin Öğrenme Nedir? Makine Öğrenimi ve Yapay Zeka İle Arasındaki Farklar Nelerdir? - Bulutistan Blog</a></li><li><a href="https://dergipark.org.tr/tr/pub/emobd/article/1338066?source=post_page-----233f97ea17f3---------------------------------------">EMO Bilimsel Dergi</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd8c30682dff" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>