<?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 Mümin Kadir Varıcı on Medium]]></title>
        <description><![CDATA[Stories by Mümin Kadir Varıcı on Medium]]></description>
        <link>https://medium.com/@mumin.varici?source=rss-9586ba92fd67------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*iOM2owpjUyA4QgrVZuTzRA.png</url>
            <title>Stories by Mümin Kadir Varıcı on Medium</title>
            <link>https://medium.com/@mumin.varici?source=rss-9586ba92fd67------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 21:07:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mumin.varici/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[AI Native Architecture]]></title>
            <link>https://medium.com/software-architecture-t%C3%BCrkiye/ai-native-architecture-4af3e41c51d8?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/4af3e41c51d8</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[agentic-system]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 04:41:01 GMT</pubDate>
            <atom:updated>2026-08-11T06:26:56.818Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Bugünlerde içinde “AI” geçen her cümleye kulak kapatır olduk. Bunun en büyük nedeni içi boşaltılmış altı boş yapılar. “AI Native olduk” cümlesinin arkasında çoğu zaman tek bir değişiklik var: bir API çağrısı eklenmiş, kalan business aynı.</em></p><p>Bir süredir “AI Native Architecture” üzerine araştırmalar yaparken bir yandan da çalıştığım şirket bünyesinde AI adoption ve AI Governance konularında çalışmalar yürütüyorum. Bu yazıda bu süreçte edindiğim tecrübeler ve araştırmalarım ışığında derlenmiş bir çerçeve sundum. Bu çerçeve AI Enabled ve AI Native mimariler arasındaki farkları açıklıyor.Bu kararların her biri, bir sistemin AI Native olup olmadığını belirleyen kritik unsurlardır. Hazırsanız başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x2njhUsbl4dB1bPR" /><figcaption>Photo by <a href="https://unsplash.com/@omilaev?utm_source=medium&amp;utm_medium=referral">Igor Omilaev</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Özellikle de kurum dışında, online ve offline ortamlarda bazı mimari incelemeler ve fikir alışverişlerinin yapıldığı görüşmelerde bulunuyorum. Malesef firmalar her “hype” konuya dört koldan saldırıp bunu bir pazarlama malzemesi olarak kullanmayı çok iyi beceriyor. İnanılmaz sayılar paylaşılıyor, inanılmaz hikayeler anlatılıyor. Ama bu seferki biraz daha farklı sanki. Çünkü hem büyük bütçeler gerektiriyor(nispeten) hem de büyük bir yarış var. Biz mühendisler olarak bu köpüğün heyecanına kapılmadan gerçeklere odaklanalım.</p><p>Tüm firmalar hatta bireyler pastadan kaptığı dilimi büyütme ya da elindekini başkasına kaptırmama derdinde. Ama bir sorun var. Bazı kavramlar hem yanlış kullanılıyor hem de pazarlama malzemesi yapılıp ağızlarda ezilirken sadece söyleyenlerin ve firmaların itibarını zedeliyor. Birçok ürün veya projenin etiketi “AI Native” olarak koyulsa da bu mimarilerin çoğunda, sistemin en dışında bir LLM model katmanı bulunuyor. Bir servis API isteği alıyor, gerekli gördüğü yerde bir LLM model API’sine(internal — external) çağrı yapıyor, cevabı formatlayıp döndürüyor. Mimari diyagramda bu LLM modelleri bir kutudan ibaretken, sistemin geri kalanı onun var olmadığı günkü gibi çalışıyor.</p><p>Bu tabloyu eleştirmek kolay, ama asıl sorun etiketin kötüye kullanılması değil, tanımın hiç yapılmamış olması. “AI Native” ve “AI Enabled” arasındaki çizgiyi entegrasyon derinliğine göre çizmek, yanlış bir eksen seçmek demek. İki yaklaşımı ayıran şey modele ne kadar çağrı yapıldığı değil, dört mimari kararın nerede ve nasıl alındığı: bağlam sahipliği, non-determinizmin kabulü, geri besleme döngüsü, maliyet birimi. Bu dördü aynı anda çözülmeden atılan “AI Native” etiketi, mimari değil pazarlama sınıflandırmasıdır. Yani <em>kötüye kullanılmış</em> bir etiketten ibarettir.</p><blockquote><em>Kısaca tanımlarsak: AI-native architecture zekayı sistem tasarımına entegre eder, gerçek zamanlı kararlar alınmasını, sürekli öğrenmeyi ve ölçeklenebilir kurumsal sonuçları alabilmeyi sağlar. AI-enabled architecture ise zekayı sistem tasarımına entegre etmez, sadece bir model çağrısı ekler ve sistemin geri kalanı onun var olmadığı günkü gibi çalışır.</em></blockquote><h3>Bağlam sahipliği</h3><p>AI Enabled bir sistemde context genellikle prompt’un içine gömülü, geçici ve sahipsiz bir veridir. Geliştirici hangi belgenin, hangi veri (ve/veya seti)nin modele gideceğine karar verir. Bu karar code review sürecinde onaylanır ve orada kalır. Peki gerçekten işe yarar mı? Kısa vadede işe yarar, çünkü test ortamında yetkilendirme, veri classification ve erişim matrisi gibi kavramların hiçbiri devreye girmez. Peki o kurumun yıllar içinde koyduğu tüm policy ve kurallar nereye gitti?</p><p>Production ortamı bu resmi hızla bozar. Türkiye’deki bankacılık, sigorta ve telekom kurumlarının neredeyse tamamında müşteri verisi KVKK kapsamında sınıflandırılmış ve iç erişim matrisiyle sınırlandırılmıştır. RAG için seçilen kaynak bu matrisin dışında bir yoldan modele ulaşıyorsa, sistemin ürettiği cevap teknik olarak doğru olsa bile denetim açısından savunulamaz hale gelir. Bir demo üç-beş günde çalışır hale getirilebilir. Aynı çözümün kurumsal sürümü üç ayda ayakta durur mu soru işareti… Çünkü fark koddan değil yetkiden gelir.</p><p>AI Native bir mimaride bağlam, ayrı bir bileşen olarak tasarlanır: kaynak sistemden veri sınıflandırmasına, oradan yetki filtresine, oradan prompt’a giden bir pipeline. Bu pipeline’ın bir sahibi vardır — genellikle platform veya altyapı ekipleridir. Hangi verinin hangi tenant’a, hangi rolde, hangi amaçla gideceği code review’da değil, çalışma zamanında denetlenmelidir. Bu, RAG’ı bir özellik olmaktan çıkarıp bir veri mülkiyeti problemine dönüştürür; ve bu dönüşüm gerçekleşmeden yapılan hiçbir “AI Native” iddiası productionda uzun ömürlü olmaz.</p><blockquote><em>RAG (Retrieval-Augmented Generation), yapay zeka dil modellerinin (LLM) cevap vermeden önce dış ve güvenilir bir bilgi kaynağından (belgeler, şirket arşivleri, internet siteleri) doğru bilgiyi bulup okumasını ve cevabı bu gerçek verilere dayanarak üretmesini sağlayan bir tekniktir.</em></blockquote><h3>Nasıl kurulur?</h3><p>Pratikte bu hat dört adımdan oluşur: kaynak sistem connectörü veriyi çeker, sınıflandırma adımı her belge veya alana bir gizlilik ve tenant etiketi iliştirir (otomatik kural + gerekli yerde manuel onay), yetki filtresi isteği yapan kullanıcının veya agent’ın rolünü ve amacını bu etiketlerle karşılaştırıp süzer, son adımda yalnızca süzülmüş içerik prompt’a girer. Kritik nokta, bu süzmenin veri indekslenirken bir kere değil, her sorguda yeniden (query-time) uygulanmasıdır; çünkü kullanıcının yetkisi zamanla değişir, verinin indekslendiği andaki yetkisi değil. Ve bu erişim kontrolü merkezi bir policy engine tarafından yapılır; her tenant’ın kendi yetki matrisi ayrı ayrı tutulmaz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PasHHfywNoNH7JtVkTLVmA.png" /></figure><blockquote><em>Bağlamın yetkisi code review’da değil, çalışma zamanında denetlenir.</em></blockquote><h3>Non-determinizmin kabulü veya tolerance band</h3><p>Klasik yazılım testi binary bir mantığa dayanır(true/false veya 1/0). Beklenen çıktı bellidir, üretilen çıktı ona eşit ya da değildir. Quantum evreninde değilseniz üçüncü bir alternatiften söz edilemez. Bu mantığı model çıktısına olduğu gibi taşırsanız kısa sürede “bu cevap doğru mu” tartışmasına saplanır kalırsınız. Sorun modelin performansında değil, acceptance criteria’nın hiç yazılmamış olmasıdır. Model her defasında biraz farklı bir cevap üreti ve elinizde bu farklılığı değerlendirecek bir ölçüt olmazsa kaos başlar. Çünkü generative modellerin doğası gereği aynı prompt’a aynı bağlamla her defasında aynı cevabı üretmesi beklenemez. Bu, modelin hatalı olduğu anlamına gelmez; aksine, modelin non-deterministik(tahminelenemez) bir yapıda olduğunu gösterir.</p><p>AI Enabled sistemlerde bu boşluk genellikle insan gözüyle kapatılır: bir kişi çıktıyı okur, “iyi görünüyor” der, sonra uygulama release edilir. Ölçek büyüdükçe bu yöntem çöker, çünkü insan denetimi doğrusal olarak artan bir maliyettir ve model davranışındaki sapmayı sistematik olarak yakalamak mümkün olmaz. Bu ihtimal belki runtime’da hiç gerçekleşmeyebilir de ama gerçekleşmemiş olması gerçekleşmeyeceği anlamına gelmez.</p><p>Buna çok bariz bir örnek verecek olursak -ki bu örneği LLM ile yapmak çılgınlık olsa da- gerçek hayatta deterministik bir problem olan iki integer toplamını hesaplayan bir LLM prompt’a 100 sefer “1+2 kaçtır?” sorusunu sorduğunuzda 100. cevabın hatalı olabileceği gerçeğidir. Bu düşününce her ne kadar mantıksız gelse de 1 ve 2 sayılarını sayı yerine text kabul edip “12” cevabını üretmesi mümkündür. Bu nedenle AI Native bir mimaride model çıktısının doğruluğu binary değil, tolerance band ile ölçülür.</p><p>AI Native bir mimaride acceptance criteria, kod kadar somut bir mühendislik çıktısıdır: hangi alanların kesin eşleşmesi gerektiği, hangi alanlarda anlamsal yakınlığın yeterli olduğu, hangi sapmanın otomatik reddedileceği baştan tanımlanır. Bu, test ekiplerinin “doğru mu” sorusunu bırakıp “tolerance band içinde mi” sorusuna geçmesini sağlar. Ölçülebilir, otomatikleştirilebilir ve CI hattına gömülebilir bir soru olduğu için, model veya prompt her değiştiğinde bu kriterler otomatik olarak test edilir.</p><h3>Nasıl ölçülür?</h3><p>Tolerance band tek bir eşik değil, katmanlı bir kontroldür. Yapısal katman çıktının beklenen şemaya uyup uymadığını doğrular ve tamamen deterministiktir. Semantik katman, üretilen cevap ile bir referans/golden dataset arasındaki anlamsal yakınlığı bir benzerlik skoruyla ölçer ve bu skor için üst ve alt kabul sınırı tanımlanır. Kural katmanı, iş mantığına özgü sabitleri (yasaklı ifadeler, zorunlu alanlar) kontrol eder. Sınırda edge caseler insan örneklem incelemesine düşer; net ihlaller otomatik reddedilir. Bu üç katman birlikte, prompt veya model her değiştiğinde CI hattında çalıştırılır. Bu bir nevi “golden dataset” ile modelin davranışını sürekli olarak test eden bir gate mekanizmasıdır. Yani benchmark değil, acceptance criteria’dır.</p><blockquote><em>Golden dataset, doğruluğu önceden onaylanmış ve modelin üretmesi beklenen cevapları içeren bir veri kümesidir. İnsan onayından geçen ve doğruluğu konusunda şüpheye yer olmayan örneklerden oluşur.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*_oXfQOE3WM4PPTlDieIUwg.png" /></figure><blockquote><em>Acceptance criteria yazılı değilse, tartışılan şey model değil, hiç var olmayan bir standarttır.</em></blockquote><h3>Geri besleme döngüsü</h3><p>AI Enabled bir sistemde model çağrısı genellikle statelesstır. Yani istek gider, cevap gelir, kullanıcıya gösterilir ve sistem o etkileşimi unutur. Sonraki sürüm, önceki sürümün production davranışı hakkında hiçbir şey bilmeden yazılır. Bu, geleneksel yazılımda alışılmadık bir durum değildir — bir buton tıklaması da genellikle iz bırakmadan geçer — ama model çıktısının kalitesi, klasik özelliklerin aksine, zamanla ve kullanımla değişir; drift(kayma/sapma) yaşanır, kullanıcı beklentisi kayar, veri dağılımı değişir.</p><p>AI Native bir mimaride production çıktısı bir veri kaynağıdır. Kullanıcı geri bildirimi, insan doğrulaması sırasında yapılan düzeltmeler ve gözlemlenen hata örnekleri etiketlenip eval setine geri döner. Bu döngü olmadan ikinci sürüm, birinci sürümün kör bir tekrarından ibaret kalır; ekip her seferinde aynı hatayı farklı bir şekilde yeniden keşfeder. Döngünün varlığı bir özellik değil, mimari bir karardır — hangi etkileşimlerin loglanacağı, nasıl anonimleştirileceği ve eval setine ne sıklıkla akacağı en baştan tasarlanmalıdır.</p><h3>Nasıl kurulur?</h3><p>Döngünün başlangıcı, her etkileşimin prompt, bağlam, çıktı, model sürümü ve zaman damgasıyla birlikte bir trace olarak saklanmasıdır. Bunun üzerine bir trace işaretleme mekanizması gelir: kullanıcının olumlu/olumsuz flagi, insan doğrulayıcının yaptığı düzeltme veya bir hata izleme kaydından açılan ticket. Yakalanan her örnek bir triage kuyruğuna düşer; burada kritik mi, tekil bir sapma mı, yoksa eval setine eklenmeye değer bir örnek mi olduğuna karar verilir. Kabul edilen örnekler sürüm numarasıyla etiketlenmiş eval setine eklenir ve bir sonraki prompt/model değişikliği bu genişlemiş sete karşı test edilir. Bir önceki golden dataset yeni sürümde genişletilmiş şekilde kullanılır; böylece modelin davranışı sürekli olarak test edilir ve drift önlenir. Bu döngü, modelin üretkenliğini ve doğruluğunu zaman içinde iyileştirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wixieRe6cpun2FIBxFjhjw.png" /></figure><blockquote><em>Geri besleme döngüsü olmadan her yeni sürüm, öncekinin kör bir tekrarıdır.</em></blockquote><h3>Maliyet token ile mi hesaplanmalıdır?</h3><p>AI projelerinin bütçe tartışması neredeyse her yerde aynı kelimeyle başlar: token. Model sağlayıcılarının “pricing” sayfası token başına ücret gösterir, bütçe planlaması da bu birim üzerinden yapılır. Ama harness maliyeti de kullanıcı veya sisteme yansıtılır. Sahadaki örneklerde bu planlama sistematik olarak işin doğası ve providerların uygulamalarından dolayı yanılıyor. Çünkü token maliyeti toplam maliyetin küçük bir parçasıdır. Asıl kalemler; başarısız denemelerin tekrarı, uzun context windowların taşınması hatta compact edilmesi, tool callinglerin art arda ve hatta auto modda devam etmesi ve de en önemlisi insan doğrulamasının aldığı süredir.</p><p>Bu nedenle AI Native bir mimaride maliyet birimi token değil, tamamlanan iş olarak kabul edilmelidir. Bu birim, bir CTO’nun “bu özelliği ölçeklendirebilir miyiz” sorusuna token fiyatından çok daha doğru bir cevap verir, çünkü ölçeklendirme kararı gerçek iş yüküne göre alınır, iyimser bir fiyat varsayımına göre değil.</p><p>Türkiye’deki kurumsal SaaS ürünlerinde tenant başına adil kullanım ve fiyatlandırma tartışması da aynı birime dayanmak zorunda; token üzerinden kurulan bir fiyatlandırma modeli, yoğun kullanan bir tenant’ın gerçek maliyetini büyük ölçüde eksik yansıtılabilir.</p><blockquote><em>Bu durumun en büyük nedeni token kullanımı non-deterministic yani tahmin edilemez olmasıdır.</em></blockquote><h3>Nasıl hesaplanır?</h3><p>Ölçüm, her isteğe atanan bir correlation id ile başlar. Bu id’nin altında model çağrısı, her retry denemesi, her araç/tool çağrısı ve insan doğrulama süresi (saatlik ücretle çarpılarak) ayrı ayrı biriktirilir. Formül basittir:</p><p><strong>İş başına maliyet = (Model çağrıları + Retry + Araç çağrıları + İnsan doğrulama süresi × saatlik ücret) / Tamamlanan iş sayısı</strong></p><p>Bu birim tenant, iş tipi ve zaman bazında kırılıp bir dashboard’a taşındığında, hangi iş türünün beklenenden pahalı olduğu token faturasından çok daha önce görülür.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*yuZKZbmwkYbNHXLY5m6QMg.png" /></figure><blockquote><em>Token fiyatı bir farazidir; iş başına maliyet bir gerçektir.</em></blockquote><h3>Entegrasyon kolaylığı, mimari olgunluk değildir</h3><p>Bu dört farkın ortak noktası, hiçbirinin model seçimiyle ilgili olmamasıdır. Aynı model, aynı prompt, iki farklı mimaride tamamen farklı bir sisteme dönüşür — fark modelde değil, onu saran mimaride. Bir model API’sini bir servise bağlamak max yarım gün hatta AI kullandığımızı düşünürsek birkaç promptla halledilir. Context sahipliğini yeniden tasarlamak, acceptance criteria’yı yazılı hale getirmek, geri besleme döngüsünü kurmak ve maliyet birimini değiştirmek ise aylar süren, birden fazla ekibi (platform, güvenlik, ürün, finans) aynı masaya oturtan bir çalışmadır.</p><p>Bu, “önce pilot, sonra production” kültüründe özellikle görünür hale gelir. Pilot aşamasında dört kararın hiçbiri gerekmez; küçük veri kümesi, sınırlı kullanıcı grubu ve gözden geçirilebilir çıktı hacmi bu eksiklikleri gizler. Productiona geçiş, tam olarak bu dört kararın aynı anda test edildiği andır — ve çoğu “AI Native” iddiasının gerçekte AI Enabled olmanın ötesine geçememesinin nedeni pilotun başarısızlığı değil, bu dört kararın pilot sırasında hiç alınmamış olmasıdır.</p><h3>Özet tablo</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cIdvw9N6IUH56uqtzZVL1g.png" /></figure><h3>Sonuç</h3><p>Bir mimarinin “AI Native” olup olmadığını tartışmak, isim üzerinden değil, bu dört sorudan geçmelidir: Bağlamınızın erişim matrisi runtimeda mı uygulanıyor, yoksa code reviewda mı onaylanıp unutuluyor? Acceptance criterianızı bir insan mı okuyor, yoksa otomatik bir tolerance band mı denetliyor? Productiondaki bir hatayı bir sonraki sürüme taşıyan yazılı bir yol var mı? Ölçeklendirme kararınızı token fiyatı mı, yoksa iş başına gerçek maliyet mi belirliyor?</p><p>Bu dört sorudan ikisine “hayır” cevabı veren bir sistem, ne kadar yeni bir model kullanırsa kullansın, AI Enabled bir sistemdir. Bunun kendisi bir sorun değildir; sorun, bunu bilerek karar vermek yerine etiketin arkasına saklanmaktır.</p><p>Bu yazıyı okuduğunuz için teşekkür ederim. Umarım AI Enabled ve AI Native mimariler arasındaki farkları anlamanıza yardımcı olmuştur. Soru ve görüşlerinizi yorumlarda ve LinkedIn üzerinden paylaşabilirsiniz.</p><p>Sonraki yazıda görüşmek üzere…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4af3e41c51d8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/software-architecture-t%C3%BCrkiye/ai-native-architecture-4af3e41c51d8">AI Native Architecture</a> was originally published in <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Optimization Trade-offs]]></title>
            <link>https://medium.com/software-architecture-t%C3%BCrkiye/optimization-trade-offs-16a5255232a7?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/16a5255232a7</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[entity-framework-core]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 21:47:53 GMT</pubDate>
            <atom:updated>2026-11-15T05:29:25.413Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Bir seri halinde devam edecek yazı dizisindeki diğer yazılara <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> publication’ı altından ulaşabilirsiniz.</blockquote><p><strong>Yüksek Trafikli Yazılım Mimarisi Serisi — Bölüm 2</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hHQUnq9J6U_zKXUl" /><figcaption>Photo by <a href="https://unsplash.com/@bdchu614?utm_source=medium&amp;utm_medium=referral">Brendan Church</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Giriş</h3><p>İlk yazıda scalability, performance ve reliability’yi nasıl ayırt ettiğimizi konuştuk.</p><blockquote>Şuradan erişebilirsiniz: <a href="https://medium.com/@mumin.varici/scalability-performans-reliability-3180b0802dec">Scalability, Performans, Reliability</a></blockquote><p>Sorunu doğru tanımlamayı öğrendik. Ama şimdi gerçek bir problem üzerine konuşalım istedim.</p><p>Sistemi hızlandırmak için bir adım atıyorsunuz ve başka bir yerde bir şey kırılıyor. Cache ekliyorsunuz, performans uçuyor; ama birkaç gün sonra kullanıcıların eski veri gördükleriyle ilgili şikayetler geliyor. Database’i shard’lamaya geçiyorsunuz, yük dağılıyor; ama artık her sorgu planlaması beş kat karmaşık hale geliyor. İşlemleri async hale getiriyorsunuz, throughput artıyor; ama stack trace’leriniz anlamsız olmaya başlıyor.</p><p>Bu yazıda şu gerçek üzerine konuşacağız: <strong>her optimizasyon bir trade-off’tur. </strong>Bazen bu trade-offlarla yüzleşir ve bir yolu tercih ederiz. Ancak buradaki en önemli konu bizim bunları yaparken bilinçli olup olmadığımızdır.</p><h3>Örnek problem</h3><p>Production sisteminde bir API gecikmesi var. Takım toplandı, çözüm bulundu: sık okunan veriyi cacheleyelim (önbelleğe alalım) dedi.</p><p>Cache ekledik. Gecikme düştü. Herkes mutlu mu? Bir süre evet.</p><p>Bir hafta sonra müşteri şikayetleri geldi. Hesap bakiyeleri eski değerleri gösteriyor. Ekip incelemiş, backend’de veri güncellenmiş. Ama cache 10 dakikada bir expire olacak şekilde ayarlanmış. Kullanıcılar 10 dakika boyunca yanlış veri görmüş.</p><p>Reliability problemi, performans çözümünden doğdu.</p><p>Peki ya sorun sadece bu değilse? Aynı anda iki farklı istek aynı bakiyeyi güncellemeye çalışıyorsa ne olur? İkisi de aynı eski değeri okur, ikisi de +100 yazar. Sonuçta sadece bir +100 uygulanmış olur.</p><blockquote>Anlatınca çok basit bir senaryo gibi gelebilir ancak bankacılık domaininden kolay bir örnek vermek adına teşbihte hata olmaz diyelim :). Ayrıca meslek hayatım boyunca o kadar basit hataların büyük problemlere neden olduğunu düşününce bu problem zor bile denebilir. Neyse yazımıza dönelim.</blockquote><p>Banka için bu kabul edilemez; bir sosyal medya like sayacı için belki sorun değildir.</p><p>Doğru çözüm ne? Duruma göre değişiyor.</p><h3>Neden bu konu önemli?</h3><p>Çünkü trade-off’ları görmezden gelirsek, sadece problemi kaydırmış oluruz. Performans iyileşir ama reliability düşer. Scalability artar ama operasyonel karmaşıklık zirve yapar.</p><p>Bilinçli trade-off yapmak ise başka bir şeydir. “Bu sistemde milisaniye bile önemli ya da 10 dakikalık veri gecikmesi kabul edilebilir” diyebilmek bir karardır. Ama “nasıl olsa cache’ler temizlenir” demek bir karar değil, bir yanılgıdır. Veya “production’da zaten bu olmaz” dediğimiz her şeyin birgün olacağı gerçeği, gün yüzüne elbet çıkar.</p><p>İki senaryo arasındaki fark: birinde ne kaybettiğinizi biliyorsunuzdur, diğerinde ise sonradan öğreniyorsunuzdur.</p><h3>Konsept</h3><h3>CAP Teoremi</h3><p>Herkesin duyduğu bu şey pratikte ne demek? CAP Teoremi şunu söylüyor: dağıtık bir sistemde aynı anda şu üçünü birden garanti edemezsiniz:</p><ul><li><strong>Consistency (Tutarlılık):</strong> Her okuma, en son yazılan veriyi döner; tüm node&#39;lar aynı veriyi görür</li><li><strong>Availability (Erişilebilirlik):</strong> Her istek bir cevap alır. Hatalı değil, ama belki eski veri olabilir.</li><li><strong>Partition Tolerance (Bölünme Toleransı):</strong> Ağ bölünse bile sistem çalışmaya devam eder.</li></ul><p>Gerçek dünyada ağ bölünmeleri kaçınılmazdır. P her zaman olacaktır. Elimizdeki gerçek seçim: <strong>C mi, A mı?</strong></p><ul><li><strong>CP sistemler</strong> (HBase, Zookeeper): Tutarlılık önce gelir. Bir bölünmede bazı istekler reddedilebilir.</li><li><strong>AP sistemler</strong> (Cassandra, DynamoDB): Her istek cevap alır. Ama veriler geçici olarak farklılık gösterebilir.</li></ul><p>İkisi de “yanlış” değil. Banka hesabı hareketi için CP isteriz. Sosyal medya beğeni sayacı için AP yeterlidir.</p><h3>Latency vs Throughput</h3><p>Latency (gecikme): tek bir isteğin uçtan uca ne kadar sürdüğü.</p><p>Throughput (verim): sistemin saniyede kaç isteği karşılayabildiği.</p><p>İkisini birden optimize etmek mümkün; ama bir noktada seçim gerekebilir.</p><p>Bir isteği senkron işleyip 50ms’de cevap verebilirsiniz. Aynı işi async kuyruğa alırsanız “cevap” 2ms’de gelir, ama gerçek sonuç dakikalar sonra hazır olur. Throughput kazandınız, ama latency kavramını değiştirdiniz. “Hızlı cevap” artık “hemen işlendi” değil, “kuyruğa alındı” anlamına geliyor.</p><p>Bu kabul edilebilir mi? Kullanıcıya sipariş onayı göndermek için async işlem uygundur. Ödeme işlemi için değil.</p><h3>Consistency vs Availability (Cache senaryosu)</h3><p>Cache, CAP teoreminin pratiğe en hızlı yansıdığı yerdir. Cache ekleyince availability ve performance artıyor, ama consistency risk altına giriyor.</p><p>Pratikte karşılaştığım üç temel strateji:</p><ul><li><strong>Cache-Aside:</strong> Uygulama cache’i kontrol eder. Cache miss olunca DB’den okur, yazar. Basit ama stale data (güncelliğini yitirmiş veri) riski var. Güncelleme gelince cache manuel temizlenmelidir.</li><li><strong>Write-Through:</strong> Her yazma işlemi hem DB’ye hem cache’e eş zamanlı gider. Tutarlılık artar ama yazma maliyeti ikiye katlanır.</li><li><strong>Write-Behind (Write-Back):</strong> Yazma önce cache’e gider, DB’ye async yazılır. En hızlı yazma performansı, ama veri kaybı riski taşır. Distributed sistemler için iyi bir çözüm gibi görünse de transactional consistency her zaman risklidir.</li></ul><p>Hangisi doğru? Context’e göre değişiyor. Ve bunu bilmeden cache eklemek, sorunu “bir süre” ertelemekten veya gözardı etmekten ibarettir.</p><h3>Pratik benzetme</h3><p>Bir muhasebe firması düşünelim:</p><ul><li><strong>Consistency (CP):</strong> Bir işlem yapıldığında tüm şubelerde kayıt anında güncellenir. Ağ kesilse bazı işlemler askıya alınır ama herkes aynı bakiyeyi görür. Para transferi için bu şarttır.</li><li><strong>Availability (AP):</strong> İşlem hızla tamamlanır. Ama gece mutabakat (reconciliation) yapılana kadar farklı şubeler geçici olarak farklı bakiyeler görebilir. Aylık özet raporu için bu yeterli.</li></ul><p>Hangi verinin ne kadar “fresh” olması gerektiği, mimarinin şeklini belirliyor.</p><h3>.NET örneği</h3><h3>Cache-Aside</h3><p>Aşağıda klasik Cache-Aside örneği görüyoruz. Bu pattern’in güçlü yanı basitliği; zayıf yanı ise güncelleme yapıldığında cache’in otomatik temizlenmemesi. Stale data nasıl temizlenir bunu göreceğiz.</p><pre>public class AccountService<br>{<br>    private readonly IDistributedCache _cache;<br>    private readonly AppDbContext _db;<br>    private readonly ILogger&lt;AccountService&gt; _logger;<br><br>    public AccountService(IDistributedCache cache, AppDbContext db, ILogger&lt;AccountService&gt; logger)<br>    {<br>        _cache = cache;<br>        _db = db;<br>        _logger = logger;<br>    }<br><br>    public async Task&lt;Account?&gt; GetAccountAsync(int id)<br>    {<br>        var cacheKey = $&quot;account_{id}&quot;;<br>        var cached = await _cache.GetStringAsync(cacheKey);<br><br>       // Cache hit: taze veri varsa JSON&#39;dan deserialize et<br>        if(cached is not null)<br>        {<br>            _logger.LogDebug(&quot;Account {Id} cache&#39;den döndü&quot;, id);<br>            var options = new JsonSerializerOptions <br>            { <br>              PropertyNameCaseInsensitive = true <br>            };<br>            return JsonSerializer.Deserialize&lt;Account&gt;(cached, options);<br>        }<br><br>        // Cache miss: DB&#39;den oku<br>        var account = await _db.Accounts<br>            .AsNoTracking() // Tracking disabled — sadece okuma işlemi<br>            .FirstOrDefaultAsync(x =&gt; x.Id == id);<br><br>        if (account is null)<br>            return null;<br><br>        // Cache&#39;e yazarak sonraki okumayı hızlandır<br>        var json = JsonSerializer.Serialize(account);<br>        await _cache.SetStringAsync(<br>            cacheKey,<br>            json,<br>            new DistributedCacheEntryOptions<br>            {<br>                // TTL trade-off: 10 dk boyunca kullanıcı gerekirse eski bakiye görebilir<br>                // Ama her request&#39;te DB&#39;ye gitmiyoruz. throughput kazancı<br>                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)<br>            }<br>        );<br><br>        return account;<br>    }<br><br>    public async Task UpdateBalanceAsync(int id, decimal amount)<br>    {<br>        var account = await _db.Accounts.FirstOrDefaultAsync(x =&gt; x.Id == id);<br>        if (account is null)<br>        {<br>            _logger.LogWarning(&quot;Account {Id} bulunamadı&quot;, id);<br>            return;<br>        }<br><br>        // Bakiye güncelle<br>        account.Balance += amount;<br>        <br>        // DB&#39;ye commit et<br>        await _db.SaveChangesAsync();<br><br>        // Kritik: Cache invalidation stale data&#39;nın hiç olmaması için<br>        // Sonraki GetAccountAsync() çağrısında DB&#39;den taze veri alınacak<br>        var cacheKey = $&quot;account_{id}&quot;;<br>        await _cache.RemoveAsync(cacheKey);<br>        <br>        _logger.LogInformation(&quot;Account {Id} güncellendi: +{Amount}, Cache invalidated&quot;, id, amount);<br>    }<br>}</pre><h3>Write-Through</h3><p>Write-Through pattern’de her güncelleme hem veritabanına hem cache’e yazılıyor. Yazma işlemi biraz daha yavaş, ama okuma her zaman güncel veri döndürüyor.</p><pre>public class WriteThroughAccountService<br>{<br>    private readonly IDistributedCache _cache;<br>    private readonly AppDbContext _db;<br><br>    public WriteThroughAccountService(IDistributedCache cache, AppDbContext db)<br>    {<br>        _cache = cache;<br>        _db = db;<br>    }<br>  <br>    public async Task UpdateBalanceAsync(int id, decimal amount)<br>    {<br>        var account = await _db.Accounts.FirstOrDefaultAsync(x =&gt; x.Id == id);<br>        if (account is null) return;<br>        account.Balance += amount;<br><br>        // 1. Veritabanına com mit et (consistency guarantee)<br>        await _db.SaveChangesAsync();<br><br>        // 2. Aynı anda cache&#39;e de yaz — consistency&#39;yi koruyoruz<br>        var cacheKey = $&quot;account_{id}&quot;;<br>        var json = JsonSerializer.Serialize(account);<br>        await _cache.SetStringAsync(<br>            cacheKey,<br>            json,<br>            new DistributedCacheEntryOptions<br>            {<br>                // TTL reset edilir — cache&#39;ten okunan veri her zaman günceldir<br>                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)<br>            }<br>        );</pre><h3>Optimistic Locking</h3><p>Race Condition ve Consistency Trade-off’u:</p><p>Aynı anda iki istek aynı bakiyeyi güncellemek isterse ne olur? Her ikisi de eski değeri okur, her ikisi de +100 ekler. Sonuçta sadece bir +100 uygulanmış olur, diğeri kaybolur.</p><p>Bunun çözümü için iki seçenek var: pessimistic locking (kilitleyerek beklet) veya optimistic locking (çakışmayı önlemek değil, yakalamak). Pessimistic locking throughput’u düşürür. Optimistic locking bazı isteklerin retry etmesini gerektirir ama sistemi daha akıcı tutar.</p><pre>/// &lt;summary&gt;<br>/// EF Core&#39;un built-in Optimistic Concurrency desteğiyle çakışma taraması vardır.<br>/// &lt;/summary&gt;<br>public class Account<br>{<br>    public int Id { get; set; }<br>    public decimal Balance { get; set; }<br>    public string AccountHolder { get; set; } = string.Empty;<br><br>    /// &lt;summary&gt;<br>    /// Her SaveChanges()&#39;de otomatik güncellenen concurrency token.<br>    /// İki concurrent istek farklı RowVersion&#39;larla yazma çalışırsa<br>    /// DbUpdateConcurrencyException fırlatılır.<br>    /// <br>    /// .NET 10 Collection initializer: byte[] RowVersion { get; set; } = [];<br>    /// &lt;/summary&gt;<br>    [Timestamp]<br>    public byte[] RowVersion { get; set; } = [];<br>}<br><br>public class ConcurrencyAwareAccountService<br>{<br>    private readonly AppDbContext _db;<br>    private readonly ILogger&lt;ConcurrencyAwareAccountService&gt; _logger;<br><br>    public ConcurrencyAwareAccountService(AppDbContext db, ILogger&lt;ConcurrencyAwareAccountService&gt; logger)<br>    {<br>        _db = db;<br>        _logger = logger;<br>    }<br><br>    public async Task&lt;bool&gt; TryUpdateBalanceAsync(int id, decimal amount)<br>    {<br>        try<br>        {<br>            var account = await _db.Accounts.FirstOrDefaultAsync(x =&gt; x.Id == id);<br>            if (account is null)<br>            {<br>                _logger.LogWarning(&quot;Account {Id} bulunamadı&quot;, id);<br>                return false;<br>            }<br><br>            // Bakiye artır (optimistic varsayım: başka kimse değiştirmemiştir)<br>            account.Balance += amount;<br><br>            // SaveChanges: EF Core tarafından RowVersion kontrol edilir<br>            // Eğer başka bir thread araya girmişse → DbUpdateConcurrencyException<br>            await _db.SaveChangesAsync();<br>            <br>            _logger.LogInformation(&quot;Account {Id} başarıyla güncellendi: +{Amount}&quot;, id, amount);<br>            return true;<br>        }<br>        catch (DbUpdateConcurrencyException ex)<br>        {<br>            // Optimistic Locking trade-off:<br>            // Bu istek başarısız (hata)<br>            // Ama hiçbir güncelleme kaybolmadı — retry ile tamamlanabilir<br>            _logger.LogWarning(<br>                ex,<br>                &quot;Concurrency conflict: Account {Id} başka thread tarafından güncellendi. Retry gereklidir.&quot;,<br>                id<br>            );<br>            return false;<br>        }<br>    }<br>}</pre><p>Bu üç yaklaşımı yan yana koyduğumuzda her birinin farklı bir şeyi feda ettiğini görüyoruz. Cache-Aside bazı durumlarda consistency’yi; Write-Through yazma hızını; Optimistic Locking ise bazı isteklerde ilk denemede başarıyı feda ediyor.</p><h3>Cache penceresinden</h3><p>Bu yazıda üç farklı caching stratejisine baktık. Her birini aynı üç metrikle değerlendirince belirtilen durumlar ortaya çıkıyor.</p><p>“En iyi” strateji diye bir şey maalesef yok. Hangi metriği ne kadar değer verdiğinize veya üzerinde çalışılan duruma göre seçim değişiyor.</p><p>Banka bakiyesi için Cache-Aside + invalidation veya Write-Through mantıklı. Reklam gösterim sayacı için Write-Behind kabul edilebilir. Ürün kataloğu için sadece TTL ile Cache-Aside yeterli.</p><h3>Yanılgılarım</h3><p><strong>“Cache ekledik, iş bitti.”</strong> Cache, sorunun kendisi olabilir. Invalidation stratejisi planlanmadan cache eklemek, veri tutarsızlığını sistemin içine gömmektir. Bunu birkaç kez yaşadım — “cache var, neden yanlış veri görüyorlar?” sorusu haftalar aldı.</p><p><strong>“Async yapalım, scalable olalım.”</strong> Async kod yazmak, sistemi otomatik olarak scalable yapmaz. Fire-and-forget ile tamamı başarılı olmasını beklediğim ama sonucu kayıp işlemler yaşadım; bir servis çağrısını await etmeyi unutmak, hata mesajını da birlikte kaybetmek demek. Async’i yanlış yerde kullanmak; deadlock, thread exhaustion ve takip edilmesi güç hatalar doğurabilir.</p><p><strong>“Consistency her zaman önce gelir.”</strong> Bazı veriler için <strong>eventual consistency</strong> tamamen kabul edilebilir. Her şeyi <strong>strongly consistent</strong> yapmak sistemi gereksiz yavaş ve karmaşık hale getirebilir. Doğru soruyu sormak gerekiyor: “Bu veri kaç saniye eski olabilir?”.</p><h3>“Quick fixes”</h3><p><strong>Cache invalidation audit</strong></p><p>Var olan cache kullanımlarını gözden geçirebilirsiniz. Her Set çağrısı için şunu sorun: &quot;Bu veri güncellenince cache temizleniyor mu?&quot;</p><pre>// Sadece TTL&#39;e güvenmek<br>await _cache.SetStringAsync(key, value, new DistributedCacheEntryOptions<br>{<br>    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)<br>});</pre><pre>// TTL + Explicit invalidation — update/delete metodlarında mutlaka:<br>await _cache.RemoveAsync(key);</pre><p><strong>Concurrency Test</strong></p><p>Aşağıdaki tool yerine browser üzerinden replay veya basit bir powershell script vs de kullanılabilir. Ek olarak test edilecek api endpointine delay eklemek de değerlendirilebilir.</p><pre># dotnet-bombardier ile paralel yazma testi<br>dotnet tool install -g bombardier<br>bombardier -c 50 -n 1000 -m POST http://localhost:5000/api/accounts/1/balance</pre><pre># Testten sonra: DB&#39;deki nihai bakiye ile beklenen değeri karşılaştırın<br># Fark varsa race condition yaşıyorsunuzdur</pre><p><strong>“Data Freshness” sınıflandırması</strong></p><p>Her veri kaynağınız için bir soru sorun: “Bu veri X süre eski olabilir mi?”</p><h3>Sıradaki konu</h3><p>Artık trade-off’ları görüyoruz ve bilinçli seçim yapıyoruz. Ama şimdi yeni bir soru geliyor:</p><p><strong>Peki bu kararları verirken hangi sayılara bakıyoruz?</strong></p><p>Latency’ye mi bakmalıyız, throughput’a mı? P99 mi, ortalama mı? Ve bu sayılar bize ne zaman yalan söylüyor?</p><p>Bir sonraki yazıda: <em>“Load, Throughput, Latency” </em>gibi metriklere göre sayıların nasıl ve ne zaman yalan söylediğine bakacağız<em>”</em></p><h3>Peki ya sizin deneyimleriniz?</h3><p>Bir cache invalidation hatası yüzünden kullanıcılarınıza yanlış veri gösterdiyseniz fark etmek ne kadar sürdü?</p><p>Ya da bir async pattern yüzünden sessizce kaybolan işlemler yaşadıysanız nasıl tespit ettiniz?</p><blockquote>Bir seri halinde devam edecek yazı dizisindeki diğer yazılara <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> publication’ı altından ulaşabilirsiniz.</blockquote><p>Önceki yazıya ulaşmak için tıklayabilirsiniz <a href="https://medium.com/software-architecture-t%C3%BCrkiye/scalability-performans-reliability-3180b0802dec?postPublishedType=repub">Scalability, Performans, Reliability</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16a5255232a7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/software-architecture-t%C3%BCrkiye/optimization-trade-offs-16a5255232a7">Optimization Trade-offs</a> was originally published in <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scalability, Performans, Reliability]]></title>
            <link>https://medium.com/software-architecture-t%C3%BCrkiye/scalability-performans-reliability-3180b0802dec?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/3180b0802dec</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[resilience]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Sun, 29 Mar 2026 14:25:57 GMT</pubDate>
            <atom:updated>2026-11-15T05:28:29.976Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> publication’ı altında yayınlanan ve bir seri halinde devam edecek yazı dizisidir.</blockquote><p><strong>Yüksek Trafikli Yazılım Mimarisi Serisi — Bölüm 1</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D-_-eTgE3kKqKIWI" /><figcaption>Photo by <a href="https://unsplash.com/@omilaev?utm_source=medium&amp;utm_medium=referral">Igor Omilaev</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Giriş</h3><p>Bir süre önce ürettiğim içeriklere baktım ve şunu fark ettim: teknik derinlik iddiasında olan pek çok yazı, aslında aynı terim yığınını farklı sırayla diziyordu. “High availability”, “low latency”, “resilient architecture”… Ama bunların ne anlama geldiğini, pratikte nasıl birbirinden ayrıldığını gerçekten açıklayan az yazı vardı.</p><p>Bu seriyi tam da bu yüzden başlatıyorum. Yüksek trafikli sistemler kurarken benim de yanlış anladığım, yanlış uyguladığım kavramları öğretmek için değil; birlikte düşünmek için sizlerle paylaşmaya karar verdim.</p><p>İlk durağımız: Scalability (ölçeklenebilirlik), Performans ve Reliability (güvenilirlik). Çoğu zaman birbirinin yerine kullanılıyor. Ama aslında üç farklı soru soruyorlar.</p><h3>Örnek problem</h3><p>Sisteminiz yavaşladı. Ekibi topluyorsunuz.</p><blockquote><strong><em>DBA:</em></strong><em> “Veritabanım iyi, sorun bende değil.” </em><strong><em>Sistemi izleyen mühendis:</em></strong><em> “Monitoring verilerime baktım, normal görünüyor.” </em><strong><em>DevOps:</em></strong><em> “Infrastructure sağlam. 99.99% uptime’ım var.” </em><strong><em>Developer:</em></strong><em> “Kodum best practicelere uygun, hata başka yerde olmalı.”</em></blockquote><p>Dördü de haklı. Ama dördü de farklı şeyden konuşuyor.</p><p>Bu sahneyi defalarca kez yaşadım. Kiminde tüm rollere sahip biri olarak küçük bir ekipte, kiminde de büyük firmalardan birinde farklı pozisyonlarda. Ve sorunu bazen haftalar sonra bulduk — çünkü hangi soruyu sorduğumuzu bilmiyorduk. Doğru tanıyı koymadan doğru tedaviyi seçemezsiniz.</p><h3>Neden bu konu önemli?</h3><p>Yüksek trafikli bir mimari oluştururken bu üç kavramı karıştırırsanız, yanlış yere para ve zaman harcarsınız. Kısa vadede ek kaynak eklemek problemi çözüyor gibi görünse de, aslında onu halının altına süpürmüş oluruz.</p><p>Yeni bir web sunucusu eklemek scalability problemini çözmez. Cache eklemek reliability’i bozabilir. Database index’i optimize etmek tek kullanıcı için mucizevi sonuç verirken 10.000 eş zamanlı bağlantıda hiçbir şey değişmeyebilir.</p><p>Bu nedenle <strong>doğru soruyu sormak</strong>, doğru cevabı bulmaktan önce geliyor.</p><h3>Konsept</h3><h3>Performans (tek istek ne kadar hızlı?)</h3><p>Tek bir kullanıcı, tek bir istek. API’niz ne kadar sürede cevap veriyor?</p><p>Bu, en sezgisel kavram. Ölçmesi en kolay, iyileştirmesi en görünür olanı. 100ms’de cevap veriyorsa “hızlı” diyoruz ve mutlu oluyoruz.</p><p>Ama performans sadece şu soruya cevap verir: <em>“Şu an, bu API ucu tek başına, ne kadar hızlı?”</em></p><h3>Scalability (Ölçeklenebilirlik, yük altında ne oluyor?)</h3><p>10 kullanıcıdan 10.000&#39;e çıktığınızda, o 100ms hâlâ 100ms mi?</p><p>Scalability, yükle birlikte performansın nasıl değiştiğini ölçüyor. Yatay ölçeklenme (horizontal scaling) — sisteme yeni node/server/pod ekleyerek büyüyebilme; ya da dikey ölçeklenme (vertical scaling) — mevcut sunucunun resource kapasitesini artırma. İkisi de bu soruya verilen yanıtlar.</p><p>Buradaki soru: <em>“Kalabalıklaştığında sistem nasıl davranıyor?”</em></p><h3>Reliability (güvenilirlik, bir şey kırıldığında ne oluyor?)</h3><p>Bir servis çöktüğünde, bir bağlantı koptuğunda, bir disk dolduğunda — sisteminiz ne yapıyor?</p><p>Uptime yüzdesi bu soruyu tam karşılamıyor. %99.99 uptime olan ama hata mesajı handle etmeyen bir sistem, “açık ama kırık” durumda olabilir. Reliability; <strong>graceful degradation</strong> (zarif bozulma), yani sistemin bir parçası arızalandığında geri kalanının çalışmaya devam edebilmesi demek.</p><p>Buradaki soru: <em>“Felaket senaryosunda sistem ayakta kalabiliyor mu?”</em></p><h3>Pratik benzetme</h3><p>Bu konuyu daha görünür kılmak için bir restoran açtığımızı düşünelim:</p><ul><li><strong>Performans:</strong> Tek bir müşteriye yemeği ne kadar hızlı servis ediyoruz?</li><li><strong>Scalability:</strong> Saat 13:00&#39;de 200 müşteri geldiğinde 30 dakikada herkese yemek çıkarabilir miyiz?</li><li><strong>Reliability:</strong> Mutfak ocağı arızalandığında, soğuk mezelerle masaları idare edip akşama kadar açık kalabilir miyiz? Ya da balık dolabı arızalandığında hâlâ tavuk servis edebilir miyiz?</li></ul><h3>.NET kodu</h3><p>“Çok konuştuk, biraz da kodlar konuşsun” demeden önce hemen bunları örnekleyelim.</p><h3>Yüksek performans, düşük scalability</h3><p>Aşağıda geliştirme ortamında hızlı çalışırken, production’da 100 eş zamanlı istekle 300 database round-trip üreten bir Entity Framework kod parçacığı görüyoruz. Buradaki esas problem, “I/O bound işlemlerde roundtrip az olmalıdır” kuralının ihlalidir.</p><pre>public class OrderService<br>{<br>    private readonly AppDbContext _db;<br>    public async Task&lt;Order&gt; GetOrderAsync(int id)<br>    {<br>        var order = await _db.Orders<br>            .FirstOrDefaultAsync(x =&gt; x.Id == id);<br><br>        var items = await _db.OrderItems<br>            .Where(x =&gt; x.OrderId == id)<br>            .ToListAsync();<br><br>        var user = await _db.Users<br>            .FirstOrDefaultAsync(x =&gt; x.Id == order.UserId);<br><br>        return MapOrder(order, items, user);<br>        // 100 eş zamanlı istek = 300 database sorgusu<br>        // Her biri 100ms olsa bile toplamda sistem boğuluyor<br>    }<br>}</pre><h3>Performansı korunmuş, scalable sistem</h3><p>Aşağıdaki kod parçacığında DB roundtrip problemi ortadan kaldırılmış; cachelenmesi uygun olan nesne belli bir süre memory veya distributed cache’de saklanıyor.</p><pre>public class OptimizedOrderService<br>{<br>    private readonly AppDbContext _db;<br>    private readonly IXXXXCache _cache; // İster memory, ister distributed cache olsun fark etmez.<br>    private readonly ILogger&lt;OptimizedOrderService&gt; _logger;<br><br>    public OptimizedOrderService(<br>        AppDbContext db,<br>        IXXXXCache cache,<br>        ILogger&lt;OptimizedOrderService&gt; logger)<br>    {<br>        _db = db;<br>        _cache = cache;<br>        _logger = logger;<br>    }<br><br>    public async Task&lt;Order&gt; GetOrderAsync(int id)<br>    {<br>        var cacheKey = $&quot;order_{id}&quot;;<br><br>        // Cache hit kontrolü — aynı istek tekrar DB&#39;ye gitmiyor<br>        if (_cache.TryGetValue(cacheKey, out Order cachedOrder))<br>        {<br>            _logger.LogDebug(&quot;Order {OrderId} cache&#39;den döndü&quot;, id);<br>            return cachedOrder;<br>        }<br><br>        // Tek sorguda tüm ilişkili veriyi çek<br>        var order = await _db.Orders<br>            .AsNoTracking() // Change tracking overhead&#39;ini kaldır<br>            .Include(x =&gt; x.Items)<br>            .Include(x =&gt; x.User)<br>            .FirstOrDefaultAsync(x =&gt; x.Id == id);<br><br>        if (order is null)<br>            return null;<br><br>        // 5 dakika boyunca cache&#39;le<br>        _cache.Set(cacheKey, order, TimeSpan.FromMinutes(5));<br><br>        _logger.LogDebug(&quot;Order {OrderId} DB&#39;den okundu, cache&#39;lendi&quot;, id);<br>        return order;<br>        // 100 eş zamanlı istek = pratikte 1 database sorgusu<br>    }<br>}</pre><h3>Reliability için “Circuit Breaker” + “Bulkhead”</h3><p>Bir önceki kod parçacığında performans sorunumuz yoktu. Ancak sistemi gerçekten güvenilir ve kırılganlığı az bir hale getirmek için Circuit Breaker pattern ile güvence altına alalım.</p><blockquote>Yeri gelmişken bu konudaki kafa karışıklığına da değinmek istiyorum. Evlerimizdeki sigorta kutusunu düşünelim: elektrik fazla yüklendiğinde devre kesici devreye girer, lambalar söner — ama ev yanmaz. Yazılımda circuit breaker da tam bunu yapıyor: art arda hata alan bir servise gelen istekleri keser, sistemi korur. Belirli bir süre sonra servisi test eder — düzeldiyse trafiği açar, düzelmediyse kapalı tutmaya devam eder.</blockquote><blockquote><strong>Bulkhead</strong> ise bir geminin su geçirmez bölmelerini düşünelim: geminin arka tarafında bir delik açılsa bile diğer bölmeler su almaz, gemi batmaz. Yazılımda bulkhead da aynı mantıkla çalışıyor: sisteminizin bir bölümüne gelen istek sayısını sınırlıyorsunuz, böylece bir servis patladığında tüm sistem değil sadece o bölme “su alıyor”. Örneğimizde maksimum 10 paralel işlem ve 50 kuyruk dedik — 51. istek geldiğinde geri çevriliyor, ama geri kalan 60 istek hâlâ sağlıklı çalışmaya devam ediyor.</blockquote><pre>// Microsoft.Extensions.Http.Resilience (Polly v8) ile<br>// sistem bir parçası kırıldığında diğerlerini koruyoruz<br><br>public class ResilientOrderService<br>{<br>    private readonly OptimizedOrderService _inner;<br>    private readonly ResiliencePipeline&lt;Order?&gt; _pipeline;<br><br>    public ResilientOrderService(OptimizedOrderService inner)<br>    {<br>        _inner = inner;<br><br>        _pipeline = new ResiliencePipelineBuilder&lt;Order?&gt;()<br>            // Circuit Breaker: 3 ardışık hata sonrası 30 saniye devre açılıyor<br>            .AddCircuitBreaker(new CircuitBreakerStrategyOptions&lt;Order?&gt;<br>            {<br>                MinimumThroughput = 3,<br>                BreakDuration     = TimeSpan.FromSeconds(30),<br>                SamplingDuration  = TimeSpan.FromSeconds(60),<br>                FailureRatio      = 0.5,<br>                OnOpened = args =&gt;<br>                {<br>                    Console.WriteLine($&quot;Circuit açıldı - {args.BreakDuration.TotalSeconds}s bekliyor&quot;);<br>                    return ValueTask.CompletedTask;<br>                },<br>                OnClosed = _ =&gt;<br>                {<br>                    Console.WriteLine(&quot;Circuit kapandı - servis yeniden deniyor&quot;);<br>                    return ValueTask.CompletedTask;<br>                }<br>            })<br>            // Bulkhead: Aynı anda max 10 paralel işlem, arkada 50 kuyruk<br>            .AddConcurrencyLimiter(permitLimit: 10, queuedTasksLimit: 50)<br>            .Build();<br>    }<br><br>    public async Task&lt;Order?&gt; GetOrderAsync(int id)<br>    {<br>        return await _pipeline.ExecuteAsync(<br>            async ct =&gt; await _inner.GetOrderAsync(id),<br>            CancellationToken.None // Veya valid bir token geçebiliriz.<br>        );<br>    }<br>}</pre><p>Bu örneklerde görüldüğü üzere sistemimiz gelen yük karşısında ezilmeyecek hale gelmiş oldu.</p><h3>DB penceresinden</h3><p><strong>Performans açısından</strong> index mucizevi çalışır: tek bir sorgu 2 saniyeden 50ms’ye düşer. Ölçülebilir, görünür, etkileyici. “Sorunu çözdük” diye sevinirsiniz.</p><p><strong>Scalability açısından</strong> ise index yeterli değildir: 10.000 eş zamanlı bağlantı geldiğinde sorun artık “sorgu ne kadar hızlı?” değil, “veritabanı kaç bağlantıyı aynı anda taşıyabilir?” sorusuna dönüşür. Index her sorguyu hızlandırır ama bağlantı havuzunu (connection pool), lock çakışmalarını, I/O kapasitesini yönetemez. Yani dar olan yol değişmedi, sadece içinden geçen arabalar biraz daha hızlı gitti.</p><p><strong>Reliability açısından</strong> ise optimizasyon hiçbir şey söylemez: index ne kadar iyi olursa olsun, veritabanı sunucusu çöktüğünde sistem ne yapacağını bilmiyorsa bu iyileştirme güvenilirliğe tek kuruş katkı sağlamaz.</p><h3>Yanılgılarım…</h3><p><strong>“Geliştirmede hızlıysa production’da da hızlıdır.”</strong> Load test olmadan hiçbir scalability iddiası geçerli değil. Ben de zaman içerisinde bu yanılgıya düştüm. Tek kullanıcılı testlerle güvende olduğumuzu sandım.</p><p><strong>“Cache her şeyi çözer.”</strong> Cache ekleyince reliability sorunu başlayabilir. Stale data (güncelliğini yitirmiş veri) sunabilir duruma geldim. Cache invalidation beklenmedik karmaşıklık yaratabilir. “Hızlı çözüm” diye eklediğimiz cache’in ardından saatler harcadım.</p><p><strong>“Uptime yüzdesi yüksekse sistem güvenilirdir.”</strong> Bir servis çalışıyor ama her hatada 500 döndürüyor olabilir. Reliability, hata anında ne yaptığınızla ilgili.</p><h3>Hemen yapabileceğiniz</h3><p>Bu yazıyı okuduktan sonra aynı gün şunları yapabilirsiniz:</p><p><strong>Performans baseline</strong></p><pre># dotnet-trace ile mevcut API&#39;nizde darboğazı tespit edin<br>dotnet tool install --global dotnet-trace<br>dotnet-trace collect --process-id [PID] --duration 00:00:30 #veya dotnet trace collect --name [app-name] --duration 00:00:30</pre><p><strong>Scalability audit</strong></p><pre>// MiniProfiler ile N+1 sorgularını yakalayın (.NET 10 - minimal API)<br>builder.Services.AddMiniProfiler(opt =&gt; opt.RouteBasePath = &quot;/profiler&quot;)<br>                .AddEntityFramework();<br>app.UseMiniProfiler();</pre><blockquote><em>Testlerden çıkan sonuç: 10 müşteri için N+1 = 11 sorgu / 46ms → Include ile = 1 sorgu / 21ms (2.2× hız, 10 sorgu tasarrufu)</em></blockquote><p><strong>Reliability safety net</strong></p><pre>// En kritik endpoint&#39;inize circuit breaker ekleyin<br>// Microsoft.Extensions.Http.Resilience — .NET 10 önerilen yöntem<br>builder.Services.AddHttpClient&lt;OrderClient&gt;()<br>      .AddResilienceHandler(&quot;circuit-breaker&quot;, pipeline =&gt;<br>      {<br>          pipeline.AddCircuitBreaker(new HttpCircuitBreakerStrategyOptions<br>          {<br>              MinimumThroughput = 3,<br>              BreakDuration     = TimeSpan.FromSeconds(15),<br>              SamplingDuration  = TimeSpan.FromSeconds(30),<br>              FailureRatio      = 0.5<br>          });<br>      });</pre><blockquote><em>Testlerden çıkan sonuç: 3 başarısız deneme → devre açıldı → sonraki 3 çağrı HTTP’ye hiç gitmedi (fast-fail)</em></blockquote><p>Çalışan örnek: <a href="https://github.com/muminvarici/high-load-systems/tree/main/Scalability%2C%20Performance%2C%20Reliability">chapter-01-quick-start</a></p><h3>Test sonuçları</h3><p>Aşağıdaki sonuçlar, chapter-01-quick-start projesini .NET 10 üzerinde çalıştırarak ölçüldü. 10 müşteri, her müşteriye 5 sipariş (toplam 50 kayıt).</p><h3>Scalability N+1 vs optimized</h3><p>YaklaşımSQL Sorgu SayısıSüreN+1 (kötü)1144 msInclude/JOIN (iyi)119 ms<strong>Fark10 sorgu tasarrufu2.3× hızlanma</strong></p><p>/scalability/n-plus-one endpoint&#39;i çağrıldığında EF Core her müşteri için ayrı bir SELECT atar: 1 (müşteri listesi) + 10 (her müşteri için siparişler) = <strong>11 sorgu</strong>. /scalability/optimized endpoint&#39;i ise tek bir JOIN ile tüm veriyi çeker: <strong>1 sorgu</strong>.</p><h3>Reliability Circuit Breaker</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*_dhzTq_hH7s4Cf7OJWSrAw.png" /></figure><p>3 ardışık hata sonrası devre açıldı. Sonraki istekler HTTP’ye hiç ulaşmadan anında reddedildi — kırık bir servise yük bindirme ve gereksiz timeout bekleme sona erdi.</p><p>MiniProfiler detayları için: <a href="http://localhost:5141/profiler/results-index">http://localhost:5141/profiler/results-index</a></p><h3>Sıradaki konu</h3><p>Artık üçünü ayırt ediyoruz. Ama asıl zor soru şu geliyor:</p><p><strong>Peki ya birini iyileştirmek diğerini bozuyorsa?</strong></p><p>Cache eklemek reliability’i tehdit ediyor. Database sharding scalability kazandırıyor ama sistem karmaşıklığı uçuyor. Bu trade-off’ları nasıl yönetiyoruz?</p><p>Bir sonraki yazıda: <em>“Optimization Trade-offs” </em>konusunu işlerken hangi metrikleri feda edebiliriz? bunu inceleyeceğiz.</p><h3>Peki ya sizin deneyimleriniz?</h3><p>Kendi sistemlerinizde bu üçünden hangisini en çok göz ardı ettiniz?</p><p>Performans’ı mükemmelleştirip scalability’yi unuttunuz mu? Yoksa uptime’a bakıp reliability’yi boş mu geçtiniz?</p><blockquote>Bir seri halinde devam edecek yazı dizisindeki diğer yazılara <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> publication’ı altından ulaşabilirsiniz.</blockquote><p>Sonraki yazıya ulaşmak için tıklayabilirsiniz <a href="https://medium.com/software-architecture-t%C3%BCrkiye/optimization-trade-offs-16a5255232a7">Optimization Trade-offs. Yüksek Trafikli Yazılım Mimarisi Serisi…</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3180b0802dec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/software-architecture-t%C3%BCrkiye/scalability-performans-reliability-3180b0802dec">Scalability, Performans, Reliability</a> was originally published in <a href="https://medium.com/software-architecture-t%C3%BCrkiye">Software Architecture — Türkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blockchain & NFT Çöküşü, Metaverse Balonu]]></title>
            <link>https://medium.com/@mumin.varici/blockchain-nft-%C3%A7%C3%B6k%C3%BC%C5%9F%C3%BC-metaverse-balonu-6e855722cec5?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e855722cec5</guid>
            <category><![CDATA[metaverse]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[nft]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Mon, 04 Aug 2025 22:07:05 GMT</pubDate>
            <atom:updated>2025-08-04T22:07:05.888Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8A6W3E6luG9joQkzmYyP3g@2x.jpeg" /><figcaption>Photo by <a href="https://cutt.ly/gescbaZq">julien Tromeur</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>“Yeni internet” diyerek başladık, JPEG pazarlamacılığıyla bitirdik</h3><p>Bir dönem internette dolaşan cümle şöyleydi:</p><blockquote>“JPEG kaydettim, zengin oldum.”</blockquote><p>2021’in sonunda kim blockchain konuşmuyordu? NFT koleksiyonları astronomik fiyatlara satılıyor, metaverse arsa fiyatları İstanbul Boğazı’yla yarışıyor, herkes Web3’ün “kurucusu” gibi davranıyordu.</p><p>Sonra?</p><blockquote>Hiçbir şey olmadı.</blockquote><p>Belki de olması gerekenden fazla şey bir anda oldu. NFT pazarı çöktü. Metaverse kimseyi içine çekemedi. “Yeni internet” denilen şey, bir süre sonra eski sorunları daha karmaşık terimlerle yeniden üretmeye başladı. Ve evet, o JPEG’ler… bugün hâlâ oradalar. Ama artık kimse sormuyor: “Kaç Ethereum eder?”</p><h3>NFT: Kodu var ama alıcısı yok</h3><p>NFT, teknik olarak “benzersiz dijital varlık”. Ama uygulamada, çoğu zaman “rastgele oluşturulmuş profil fotoğrafı koleksiyonu” oldu.</p><p>•	2021’in sonunda NFT satış hacmi 17 milyar doları gördü.</p><p>•	2023’te bu koleksiyonların %95’inin sıfır işlem gördüğü raporlandı.</p><p>•	En pahalı NFT koleksiyonlarının büyük kısmı bugün 100 dolara alıcı bulamıyor.</p><p>İlk başta bir yenilik vardı: Sanatçılar aracı olmadan iş satabilecek, koleksiyoncular dijitalde mülkiyet hissedecekti. Ancak iş öyle ilerlemedi. Pazar bir noktada dönüştü: Yatırım yapılacak şey, içeriği değil hype seviyesi oldu.</p><p>Kod vardı. Akıllı kontratlar vardı. Teknik alt yapı da fena değildi. Ama herkes aynı soruyu atladı: Bu şey gerçekten neden değerli?</p><h3>Metaverse: “Gireceğiz” denilen yere kimse girmedi</h3><p>2021 – 22 yıllarında metaverse öyle anlatıldı ki, dışarıda kalırsan yok olacaktın. Marka logoları Decentraland’e taşındı, sanal konserler yapıldı, arsalar milyon liraya satıldı. Fakat birkaç ay sonra platformlar sessizleşti. Geliştiriciler çekildi. Arsa fiyatları %90’dan fazla değer kaybetti.</p><p>Sorun şu: İnsanlar hâlâ fiziksel dünyada yaşıyor. Avatarla işe gitmek cazip gelmedi. Gerçek toplantı, sanal olanı yendi. Gözlük taktık ama kimse bakmadı.</p><p>Üstelik bu dünyaların pek çoğu merkeziydi. Yani “merkeziyetsizlik” diye tanıtılan şeyin veri tabanı bir şirkette duruyordu. “Yeni internet” diye satılan şey, 2010’ların kötü MMO’larına benzemeye başlamıştı.</p><blockquote>Metin2 grafikleri 10 kat daha iyiydi</blockquote><h3>Teknik gerçekler ile pazarlama efsaneleri çarpışınca</h3><p>Yazılımcı perspektifiyle bakınca bazı problemler net:</p><p>•	Karmaşık kullanıcı deneyimi: Cüzdan kur, seed kelime sakla, gas fee öde, dolandırılmamaya dua et.</p><p>•	Güvenlik eksikliği: En büyük NFT projeleri bile rug pull yaşadı, kullanıcılar dolandırıldı.</p><p>•	Spekülasyon odaklı gelişim: Birçok proje yatırım aldı ama ürün çıkaramadı. “Whitepaper” sayısı “çalışan ürün” sayısından fazlaydı.</p><p>Bu süreçte en çok gelişen şey: Launch sitesi şablonları ve Discord botları oldu. Gerçekten çalışan, sürdürülebilir projeler ise azdı.</p><h3>Web3: Biraz sisli, biraz isli</h3><p>Blockchain teknolojisi hâlâ değerli. Merkeziyetsiz yapıların finans, oyun ve içerik üretiminde bazı yenilikler sunduğu açık. Ama “her şey token” anlayışı, sistemin kendisini tüketti.</p><p>Bugün hâlâ kullanılabilir uygulamalar var:</p><p>•	Gerçek dünyadaki varlıkların tokenlaştırılması (gayrimenkul, telif, biletleme)</p><p>•	Oyun içi varlıkların zincir üzerinde taşınabilir olması</p><p>•	Daha adil içerik üretici sistemleri (royalty mantığıyla)</p><p>Ancak bu alanlar hype ile değil, kullanılabilirlikle gelişiyor.</p><h3>Sonuç: “Web3 bitti” değil, “Web3 sessizleşti”</h3><p>NFT’ler ölmedi. Metaverse yok olmadı. Blockchain çöpe gitmedi. Ama konuşanlar azaldı, hype durdu, gerçek değer ölçülmeye başlandı.</p><p>Eğer bundan sonra bu kavramlar yeniden gündeme gelecekse, bu teknik olarak iyi hazırlanmış, sürdürülebilir ve insanların günlük problemini çözen projelerle olacak.</p><p>Ve belki de bu hiç sansasyon yaratmayacak.</p><p>Ama işe yarayacak.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e855722cec5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CQRS’e Mimari Gözle Bakış]]></title>
            <link>https://medium.com/@mumin.varici/cqrse-mimari-g%C3%B6zle-bak%C4%B1%C5%9F-b72bca70da4f?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/b72bca70da4f</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[cqrs]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 19:02:44 GMT</pubDate>
            <atom:updated>2026-11-15T05:23:24.700Z</atom:updated>
            <content:encoded><![CDATA[<p>Hepimizin özel ya da iş hayatında geçtiği bazı eşikler vardır. Her bir merdiven bir üst noktaya çıkarır insanı. İşte benim de 20’li yaşlarımın sonunda <a href="https://medium.com/u/6ebd550442f4">Ciceksepeti</a> ile yaptığım mülakatta case study olarak sunduğum çalışmada, o dönemler bugün kadar popüler olmayan CQRS patterninin implementasyonunu içeren bir proje sundum. Neden CQRS kullandığım ve teknik derinlikli sorulara geldiğimizde ise karşıma şu soru geldi: “CQRS sadece code seviyesinde mi uygulanır?” Bu soru o mülakatta aslında cevaplayamadığım bir soru olsa da sonrasında hiç aklımdan çıkmadı.</p><p>İşte bu yazının da amacı tam olarak bu konuya eğilmek ve mimari bir bakış açısı ile konuya yaklaşmak.</p><p>Hazırsanız başlayalım :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8wvA6DIoRC2L-AqXBpfE1w@2x.jpeg" /><figcaption>Photo by Wolfgang Weiser on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Giriş: Yazılımda Bir Yol Ayrımı</h3><p>Bir sistemi tasarlarken, çoğu zaman şunu varsayarız: Her işlem veri yazar ve okur, dolayısıyla aynı model, aynı servis, aynı database her işimizi görebilir. Ne var ki büyüyen sistemlerde bu yaklaşımın sınırları oldukça erken hissedilir.</p><p>İşte tam bu noktada CQRS (Command Query Responsibility Segregation) karşımıza çıkar. Ancak CQRS’i sadece kod seviyesinde bir pattern olarak ele almak, onun sunduğu potansiyeli görmezden gelmek olur. Bu yazıda CQRS’e bir framework özelliği gibi değil, bir mimari düşünme biçimi olarak yaklaşacağız. Çünkü CQRS, aslında “yazılım sistemini nasıl hayal ettiğimizle” ilgilidir.</p><h3>CQRS’e Design Thinking Penceresinden Bakmak</h3><p><strong>Design Thinking</strong>, kullanıcı ihtiyaçlarını, bağlamı ve davranışı merkeze alır. Bir sistemin “okunma” ve “yazılma” biçimleri de kullanıcıların bu sistemle kurduğu ilişkinin temel parçalarıdır.</p><p>CQRS yaklaşımı da bize der ki: Komutlar (Commands) ve sorgular (Queries) özünde farklı ihtiyaçlara hizmet eder. Bu nedenle hem sistemdeki rolleri hem de mimari karşılıkları ayrıştırılmalıdır.</p><p>Bu perspektiften bakıldığında CQRS bir refactor değil, bütünsel bir tasarım kararıdır.</p><h3>Command vs Query</h3><p>Command sistemin durumunu değiştiren bir istektir. Bir kullanıcı kayıt olur, ödeme yapar, bir form gönderir. Bu işlemler doğrulama, iş kuralları ve yan etkiler içerir.</p><p>Query ise sadece veri ister. Sistemin o anki durumunu, mümkünse hızlıca ve optimize biçimde öğrenmek ister.</p><p>Bu ikisinin aynı modelle, aynı veri yapısıyla ve aynı veri erişim mantığıyla yönetilmesi uzun vadede sistem karmaşasına ve performans darboğazlarına neden olur.</p><p>CQRS, bu iki temel davranışı ayrı mimari yapılara taşıyarak sistemin daha öngörülebilir, sürdürülebilir ve optimize edilebilir olmasını sağlar.</p><h3>Write Side (Command):</h3><p>Command tarafı, iş kurallarının merkezi olarak düşünülmelidir. Burada domain logic, validation, side effect ve transaction yönetimi ön plandadır.</p><p>•	<strong>Aggregate</strong> yapıları ile domain modelleri sınırlanır ve transaction boundary netleşir.</p><p>•	<strong>DDD</strong> (Domain-Driven Design) ile uyumlu bir yapı kurularak iş mantığı kodun merkezine alınır.</p><p>•	Gerektiğinde <strong>Event Sourcing</strong> kullanılarak sadece state değil, tüm eventler saklanabilir.</p><p>Database tarafında ise bu katman genellikle normalize edilmiş ve ACID uyumlu yapılara dayanır. Çünkü consistency ve durability bu katmanın önceliğidir.</p><h3>Read Side (Query)</h3><p>Query tarafı, kullanıcıya veya servislere veri sunmakla ilgilenir. Amacı işi doğru yapmak değil, doğru veriyi hızlı sunmaktır.</p><p>•	Genellikle denormalize edilmiş, read-optimized schema’lar kullanılır.</p><p>•	NoSQL çözümleri (MongoDB, ElasticSearch gibi) veya in-memory cache yapıları bu katmanda sık tercih edilir.</p><p>•	Veriler, farklı projection’lar halinde farklı consumer’lara özel tasarlanabilir.</p><p>Read modelin veri tutarlılığı ise genellikle eventual consistency ilkesine dayanır. Çünkü yüksek ölçeklenebilirlik ve performans, anlık tam tutarlılığa tercih edilir.</p><h3>Veritabanı Stratejileri: Normalize mi, Denormalize mi?</h3><p>Command tarafında verinin bütünlüğü önemlidir. Bu yüzden normalize schema ve transaction destekleyen veritabanları (PostgreSQL, SQL Server gibi) kullanılır.</p><p>Query tarafında ise veri parçalanmış, birleştirilmiş, aggregate edilmiş, hatta belirli ekranlara özel şekilde düzenlenmiş olabilir. Burada veri tekrarından kaçınılmaz ama bu tasarım bilinçlidir.</p><p>CQRS’in doğası gereği Polyglot Persistence (her iki taraf için farklı database – nam-ı diğer micro-db) kullanımı hem doğal hem de faydalıdır. Her katman işini iyi yapan aracıyla çalışır.</p><h3>CQRS ve Microservices Uyumu ve Gerilimi</h3><p>Microservices mimarisi, bounded context’leri ayrıştırmak ister. CQRS bu ayrımı daha da netleştirir. Ancak dikkat edilmesi gereken noktalar vardır:</p><p>•	Her mikroservis kendi command ve query tarafına sahip olabilir.</p><p>• Event-driven iletişim, asenkron bir model ile veri akışını sağlar. Bu yapılar kimi zaman da CDC kullanılarak dağıtılır ancak günün sonunda yine eventually consistent bir durumdadır.</p><p>•	Message broker (Kafka, RabbitMQ, etc.) üzerinden event publication yapılabilir.</p><p>•	Outbox Pattern gibi çözümler ile transactional güvence sağlanır.</p><p>Ancak CQRS uygulamak, microservice mimarilerinde operasyonel karmaşıklığı artırabilir. Bu nedenle iyi sınırlar çizilmeli ve domain sorumlulukları net olmalıdır.</p><h3>Read ve Write Model Ayrışmasının Takıma Etkisi</h3><p>CQRS sadece bir sistem deseni değil, aynı zamanda bir organizasyon modelidir. Çünkü:</p><p>•	Ayrı modeller, ayrı ekipler anlamına gelebilir.</p><p>•	Yazan ile okuyan servislerin sahipliği ayrılabilir.</p><p>•	UI ekipleri Read tarafıyla, domain ekipleri Write tarafıyla daha yakın çalışabilir.</p><p>Bu da organizasyonel scalability sağlar. Ancak bunun yönetimi dikkat ister. Çünkü model çoğalması, öğrenme eğrisi ve test karmaşıklığı artar.</p><h3>Uygularken Dikkat Edilmesi Gerekenler</h3><p>•	Her projeye CQRS gerekmez. Basit CRUD uygulamalarında over engineering olur.</p><p>•	MVP yapılacaksa ayrıştırılmadan başlanabilir.</p><p>•	CQRS’de Kodda DRY (Don’t Repeat Yourself) yerine SRP (Single Responsibility Principle) daha önemlidir.</p><p>•	Her Command için bir Event üretmek şart değildir. Bazı yerlerde geleneksel transaction yapısı korunabilir.</p><h3>Sonuç: CQRS Bir Refactor Değil, Bir Süreçtir</h3><p>CQRS, “veriyi nasıl yöneteceğimiz” değil, “sistemi nasıl anlayacağımız” sorusuyla ilgilenir. Teknik bir çözüm değil, zihinsel bir modeldir.</p><p>Command ve Query’nin ayrı dünyalar olduğu kabul edildiğinde sistem daha okunur, daha izole, daha yönetilebilir hale gelir.</p><p>Ancak bu yolculuk, bilinçli bir tasarım kültürü gerektirir. Tüm organizasyonun bunu anlaması ve benimsemesi gerekir.</p><p>CQRS, bir pattern değil, bir sorudur:</p><p>Sistemindeki read-write işlemleri gerçekten aynı yapıyla mı yönetilmeli?</p><p>Bu soruya dürüstçe verilen cevap, seni doğru yola götürür.</p><p>Ve en önemlisi de, CQRS yalın yapılar yerine, karmaşa arttığında daha verimli bir hale gelir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b72bca70da4f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Doğa, Kod ve Mandalorian Felsefesi]]></title>
            <link>https://medium.com/@mumin.varici/do%C4%9Fa-kod-ve-mandalorian-felsefesi-9122702d4b47?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/9122702d4b47</guid>
            <category><![CDATA[phylosophy]]></category>
            <category><![CDATA[green-technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mandalorian]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Sun, 04 May 2025 21:22:22 GMT</pubDate>
            <atom:updated>2026-11-15T05:27:09.992Z</atom:updated>
            <content:encoded><![CDATA[<p>Yazılım geliştiriciliği garip bir meslek. Bir gün oturup saatlerce bir “null” ile savaşıyorsun, ertesi gün bir satır kodla dünyayı kurtaracak gibi hissediyorsun. Ama çoğu zaman, tüm bu uğraşların ortasında kendine şu soruyu sormuyorsun:</p><blockquote>“Ben ne yapıyorum?”</blockquote><p>Daha doğrusu:</p><blockquote>“Neden yapıyorum?”</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cwSe6-UV_wewhz6wPhfnzw@2x.jpeg" /><figcaption>Photo by Michael Marais on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>İşte bu yazı, bu sorunun peşine düşen bir yazılım geliştiricinin içini dökmesi, dışa sızdırması ve felsefi arayışıdır. Kod yazmanın sadece “çalışıyor mu?” ile ölçülemeyeceğini düşünenler için başka bir penceredir.</p><blockquote>Sürdürülebilir geliştirme hakkında yazdığım önceki yazıma şuradan ulaşabilirsiniz:</blockquote><blockquote><a href="https://medium.com/@mumin.varici/green-software-engineerng-kodla-do%C4%9Fay%C4%B1-koruma-sanat%C4%B1-948ed3907607">Green Software Engineering: Kodla Doğayı Koruma Sanatı | by Mümin Kadir Varıcı | Medium</a></blockquote><h3>Her Şeyin Bir Felsefesi Vardır. Kodun da.</h3><p>Her zaman söylediğim gibi, felsefesi olan şeyler hayatta kalır.</p><p>Felsefe dediğimiz şey aslında insanın anlam arayışıdır. Bir marangoz “neden bu ağacı seçtim?”, bir aşçı “bu malzemelerle ne anlatıyorum?” diye düşünüyorsa; yazılımcı da şöyle durup bir düşünmeli:</p><blockquote>“Bu API neden böyle oldu? Bu mikroservis neden var? Bu mimari neyin nesi?”</blockquote><p>Cevapları teknik belgelerde bulamazsın. Çünkü çoğu zaman gerçek cevaplar teknik değil, felsefidir.</p><p>Kodu yazarken aklında bir fikir, bir yaklaşım, bir değer varsa; işte o zaman kod yaşayan bir şeye dönüşür. Yoksa kuru kuruya “CRUD” yapıp geçeriz. (Gerçi CRUD da hayatın ta kendisi: Create, Read, Update, Delete… Doğ, öğren, değiş, öl.)</p><h3>Doğada da Patternler Var, Kodda da</h3><p>Doğa mükemmel bir yazılımcıdır aslında. Pattern&#39;lerle çalışır.</p><p><strong>Singleton mı?</strong> Güneş bir tane.</p><p><strong>Observer mı?</strong> Kuşlar birbirine öter.</p><p><strong>Garbage Collector?</strong> Doğa kendi çöpünü temizler.</p><p>Yani baktığında, doğa senin yazılım mimarinden çok daha iyi SOLID prensiplere uyuyor.</p><p>Ama biz insanlar bazen bir “feature” uğruna ekosistemi çöpe atıyoruz. Yazılımda da benzerini yapıyoruz:</p><p>•	<strong>Tek seferlik ihtiyaç için açılmış mikroservisler,</strong></p><p>•	<strong>Test yazılmadan prod’a çıkan sistemler,</strong></p><p>•<strong>	“Sonra bakarız” diyerek bırakılan TODO’lar…</strong></p><p>Bunlar yazılımın “doğal dengesini” bozuyor. Çünkü doğa gibi yazılımın da sürdürülebilir olması lazım. Her şeye rağmen yaşayan bir şey yazmak istiyorsak doğaya kulak vermeliyiz.</p><h3>Mandalorian Bunu Hep Biliyordu</h3><blockquote>“This is the way.”</blockquote><p>Bu sözü duyan herkes bilir ki, Mandalorian’ların yolu vardır. Onlar rastgele hareket etmezler. Bir şeyi nasıl yapacaklarına karar verirken sadece “en hızlısı mı?” diye sormazlar, aynı zamanda “değerlerimize uygun mu?” da derler.</p><p>Peki biz yazılımcılar?</p><p>Sürekli “en performanslı”, “en hızlı çıkan”, “en ucuz” çözümleri kovalamakla meşgulüz.</p><p>Ama bir dakika… ya “en doğru” çözüm neydi?</p><p>“En etik”?</p><p>“En az bağımlılıkla yaşayıp en fazla değer üreten”?</p><p>Hah, işte bu Mandalorian felsefesi.</p><p>Yani belki biz de her sabah bilgisayar başına geçerken içimizden şöyle demeliyiz:</p><blockquote>“Bu, benim yolum.”</blockquote><h3>Kodun Felsefesi: Katma Değer + Anlam = Kalıcılık</h3><p>Gerçek şu ki; bir yazılımcı sadece çalışan şeyler değil, anlamlı şeyler üretmelidir.</p><p>Çünkü anlam üretmeyen sistemler, bir gün gereksizleşir.</p><p>Anlamı olan kod ise nesilden nesile anlatılır (ya da en azından refactor edilmeden yaşar.)</p><p>Peki bu anlam nasıl yaratılır?</p><p>•	<strong>İnsan odaklı tasarım</strong> ile.</p><p>•	<strong>Doğaya ve sürdürülebilirliğe duyarlı yaklaşımlar</strong> ile.</p><p>•	<strong>Topluma değer katan, sadece “çalışan” değil, “katkı sunan” çözümler</strong> ile.</p><p>Evet, bu daha zor. Evet, deadline var. Ama unutma:</p><p>Kolay olanlar gelir geçer, anlamlı olanlar kalır.</p><p>Kod Yazmak Biraz da Yoga Gibidir</p><p>Bazen iki satır kodla aydınlanırsın.</p><p>Bazen if-else döngüsünde sıkışırsın.</p><p>Çoğu zaman debugger ekranında yüzleşirsin kendinle.</p><p>“Ben neden buradayım?”</p><p>“Bu hatayı neden ben aldım?”</p><p>“Hayat bu mu şimdi?”</p><p>Ama sonra çözersin.</p><p>Ve küçük bir içsel zafer yaşarsın.</p><p>O an her şeyin anlamı geri gelir.</p><p>Tıpkı hayatta olduğu gibi…</p><h3>Felsefesi Olan Kod, Zamanın Ötesini Aşar</h3><p>İyi kod, sadece çalışan kod değildir.</p><p>İyi kod; bir düşünceyle, bir değerle, bir amaçla yazılan koddur.</p><p>Doğaya saygılı, kullanıcıya duyarlı, geliştiriciye umut veren bir şeydir.</p><p>Sen de kendi yolunu çiz:</p><p>Kod yazarken felsefeni bul.</p><p>Doğaya, insana, sisteme uyumlu sistemler inşa et.</p><p>Ve her sabah bilgisayarın başına geçtiğinde kendine şunu hatırlat:</p><blockquote>“Bu, benim yolum.”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9122702d4b47" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kodun Geleceği: Yazılımcılar Kod Yazmıyor mu Artık?]]></title>
            <link>https://medium.com/@mumin.varici/kodun-gelece%C4%9Fi-yaz%C4%B1l%C4%B1mc%C4%B1lar-kod-yazm%C4%B1yor-mu-art%C4%B1k-04ea4b541f2e?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/04ea4b541f2e</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[future]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Sun, 04 May 2025 07:30:05 GMT</pubDate>
            <atom:updated>2025-05-04T07:34:09.244Z</atom:updated>
            <content:encoded><![CDATA[<p>Bir zamanlar yazılımcı dediğin, gece 3’te kahveyle ayakta duran, monitöre bakarken gözleri Matrix gibi kodlarla dolan, <strong><em>null</em></strong> hatasıyla cebelleşen kutsal bir varlıktı. Kod yazmak, neredeyse sanatsal bir faaliyetti: Her satır, bir duyguyu, bir amacı, bir “neden çalışmıyor ya bu?” isyanını barındırırdı.</p><p>Sonra… sahneye yapay zeka çıktı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uWQ1ltwX0sZkCifKnSGANQ@2x.jpeg" /><figcaption>Photo by <a href="https://wolfejohnson.com/">Steve Johnson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Kod Yazmak mı Dediniz, Onu da AI Yapar</h3><p>Eskiden kod yazmak zaman alırdı. “Sen bi backend API yaz, ben de frontend’i çıkarayım” dedikten sonra herkes kendi köşesine çekilirdi. Şimdi?</p><p>“Copilot’a yazdırdım, çalışıyor gibi ama testleri geçmiyor, sebebini ChatGPT’ye sordum” seviyesine geldik.</p><p>Bugün bir yazılımcı, sabah kahvesini içerken 3 farklı AI aracıyla birlikte bir feature’ı teslim edebiliyor. Hatta bazı günler, AI’ya ne yazması gerektiğini yazmak daha çok vakit alıyor. İlginç, değil mi?</p><h3>Yazılımcının Evrimi: Klavyeden Prompt’a</h3><p>Yazılımcı artık sadece kod yazan kişi değil. Daha çok bir orkestra şefi gibi:</p><p>– “Sen TypeScript kodunu yaz,</p><p>– Sen Swagger dokümanı çıkar,</p><p>– Sen testleri oluştur.”</p><p>Ve hepsi AI’lar.</p><p>Peki bu ne anlama geliyor? Yazılımcının rolü evriliyor. “Kod yazmak” artık işin küçük bir kısmı. Onun yerine ne geliyor?</p><p>– Ne yazılmalı, neden yazılmalı, kimin işine yarar?</p><p>– Bu çözüm ölçeklenir mi?</p><p>– Etik mi, güvenli mi, anlamlı mı?</p><p>Yani yazılımcıdan “düşünen insan” olması bekleniyor. Zor ama güzel.</p><h3>No-Code/Low-Code: Kodun Sonu mu Geldi?</h3><p>Yıllardır duyuyoruz: “Kodun sonu geldi!”</p><p>Hayır, kod hâlâ burada. Ama biraz… şekil değiştirdi.</p><p>Artık iş biriminin genç bir çalışanı, sabah ofise gelip 2 tıklamayla bir ekran geliştirip rapor yapabiliyor. Low-code platformları, “ben teknik değilim” diyenlere yazılımın kapılarını açtı. Korkmalı mıyız?</p><p>Aslında hayır. Çünkü bu araçlar basit işler için harika, ama sistemin arkasındaki mimariyi kurmak, optimizasyon yapmak, güvenlik ve ölçeklenebilirlik sağlamak hâlâ bizlerin işi. Yani: “Kod bitmedi, sadece kabuk değiştirdi.”</p><h3>Yapay Zeka ile Akıllı Yazılım Mimarileri</h3><p>Gelecekte sistemler sadece çalışmayacak, kendi kendini optimize eden, arızalarını teşhis edip çözüm bulan, belki de ihtiyaç duyduğumuzdan önce kendini güncelleyen yapılar olacak.</p><p>Science fiction değil, bu yazıdan 3 yıl sonra production’da olabilir.</p><p>Mesela bir API servisi, veri akışına göre kendi kaynaklarını yeniden ayarlayacak.</p><p>Ya da loglardan anormal bir davranışı tespit edip alarm verecek, belki düzeltecek.</p><p>Ama şunu unutmayalım: Bu tür yapılar da önce bizim hayal gücümüzle yazılıyor. AI sadece destekliyor.</p><h3>Yeni Nesil Yazılımcı: Biraz Filozof, Biraz Stratejist</h3><p>AI çağında yazılımcı, sadece teknik becerilere sahip olmamalı.</p><p>Biraz sosyolog, biraz felsefeci, bolca sistem düşünürü olmalı.</p><p>Neden mi?</p><p>Çünkü artık yazdığımız sistemlerin insan hayatına etkisi var. AI ile yönlenen sistemler, kredi notunu etkileyebilir, bir hastalığın teşhisini değiştirebilir ya da işe alım sürecini yönlendirebilir. Yani yazdığımız kod, bir hayatı etkileyebilir.</p><p>Sorumluluk büyük.</p><h3>Peki Ne Öğrenelim, Ne Yapalım?</h3><p>Bu AI fırtınasında ayakta kalmak için birkaç öneri:</p><p>•	<strong>Prompt yazmayı öğrenin</strong>: Çünkü yarının dili bu.</p><p>•	<strong>Yapay zekayı anlayın</strong>: Ne yapabilir, ne yapamaz?</p><p>•	<strong>Domain bilgisine odaklanın</strong>: Sağlık, finans, lojistik… Teknik bilgiye anlam katmak için.</p><p>•	<strong>Sistemsel düşünün</strong>: Koddan çok sistemin kendisi kıymetli.</p><p>•	<strong>Soft skill’lere yatırım yapın</strong>: İletişim, hikâye anlatma, ekip yönetimi.</p><p>Ve belki de en önemlisi: <strong>Merak etmeye devam edin</strong>.</p><h3>Sonuç: Bu Yolun Sonu Değil, Başlangıcı</h3><p>AI çağında yazılımcı olmak, sihirbaz olmaya benziyor. Elimizde sihirli araçlar var ama onları nasıl ve neden kullanacağımız hâlâ bize bağlı.</p><p>Kod yazmak belki değişiyor ama değer üretmek, problem çözmek, hayal kurmak… bunlar hâlâ insan işi.</p><p>Ve iyi haber: Yazılımcı olarak hâlâ çok değerliyiz. Sadece klavyemizi biraz daha akıllıca kullanmamız gerekiyor.</p><p>Yani: Kod bitmez. Şekil değiştirir.</p><blockquote>“This is the way.” – Bir Mandalorian yazılımcı</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=04ea4b541f2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Green Software Engineering]]></title>
            <link>https://medium.com/@mumin.varici/green-software-engineerng-kodla-do%C4%9Fay%C4%B1-koruma-sanat%C4%B1-948ed3907607?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/948ed3907607</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[sustainable-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[sustainability]]></category>
            <category><![CDATA[environment]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Wed, 08 Jan 2025 12:29:44 GMT</pubDate>
            <atom:updated>2026-03-02T12:01:45.303Z</atom:updated>
            <content:encoded><![CDATA[<p>Doğa… Kimi için sadece nefes aldığımız bir yer, benim içinse tarifi zor. Beni tanıyanlar bilir ki, doğada olmak benim için terapi gibidir. Belki de bu yüzden teknolojinin doğa üzerindeki etkilerini düşündükçe sorumluluk hissetmeye başladım. Peki, yazılım mimarisi bu konuda ne yapabilir? <strong>“Yeşil yazılım mimarisi”</strong>yle doğayı nasıl koruyabileceğimize bir bakalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BMifLqgW9YWAbE9tYIVVbQ.png" /><figcaption>Photo by <a href="https://unsplash.com/@greg_rosenke?utm_source=medium&amp;utm_medium=referral">Greg Rosenke</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4><strong>Yeşil Yazılım Mimarisi Nedir?</strong></h4><p>Kısaca, <strong>enerji verimliliği yüksek, çevresel etkisi düşük sistemler tasarlama sanatı</strong> diyebiliriz. Bu, yalnızca enerji tasarruflu kod yazmak değil; aynı zamanda sürdürülebilir altyapılar kurmak, kaynakları verimli kullanmak ve teknolojiyi doğayla uyumlu hale getirmek demektir.</p><p>Daha önce çok da sesli şekilde dile getirmesem bile, bir ormanın kalbinde bir <strong>“yazılım evi”</strong> kurma hayalim var :). Şehirlerin gürültüsünden uzak, tamamen doğayla iç içe bir çalışma ortamı. Ama o güne kadar, elimdeki teknolojiyi daha çevreci hale getirerek doğaya bir nebze katkı sağlamak istiyorum.</p><h4><strong>1. “Kodun da Bir Karbon Ayak İzi Var”</strong></h4><p>Kod yazıyoruz, derliyoruz, çalıştırıyoruz. Ama işin arka planında bu işlemler, sunucuların enerji tüketimini artırıyor. <strong>“Hello, World!”</strong> gibi basit bir uygulama bile bir veri merkezinde minik bir enerji harcıyor. Küçük görünse de büyük ölçekli uygulamalar için bu tüketim oldukça ciddi bir seviyeye ulaşabiliyor.</p><p>O zaman ne yapabiliriz?</p><p>— <strong>Algoritma Seçimi:</strong> Daha az işlem gücü gerektiren algoritmaları tercih edebiliriz. Örneğin, bir sorting işlemi yapacaksanız <strong>Quick Sort</strong> gibi optimize algoritmaları kullanmak, sistemin kaynak tüketimini ciddi şekilde düşürebilir.<br> — <strong>Asenkron Programlama:</strong> İşlemciyi boş yere bekletmek yerine paralel süreçlerle daha az enerji tüketebiliriz.<br> — <strong>Önbellekleme (Caching):</strong> Veriyi her seferinde yeniden çekmek yerine cache kullanarak enerji tüketimini azaltabiliriz.</p><h4><strong>2. Serverless</strong></h4><p>Geleneksel sunucuların aksine, <strong>Serverless mimariler</strong> yalnızca ihtiyaç duyulduğunda çalışır. Böylece boşta bekleyen kaynaklar nedeniyle enerji harcanmaz. Düşünün, şehirdeki tüm lambalar yalnızca birisi yoldan geçtiğinde yansa ne kadar enerji tasarrufu sağlanırdı? İşte serverless, tam olarak bunu yapıyor.</p><p>Ama unutmamak gerekir ki, serverless kullanırken de dikkatli olmak gerek. Verimsiz bir <strong>cold start</strong> (ilk başlatma süresi) hem performansı hem de enerji tüketimini olumsuz etkileyebilir.</p><h4><strong>3. Bulut Tabanlı Yeşil Stratejiler</strong></h4><p>Eğer bir veri merkezine ihtiyacınız varsa, kullandığınız <strong>cloud provider</strong>’ın çevresel taahhütlerine dikkat edin. Örneğin, <strong>AWS</strong>, <strong>Google Cloud</strong> ve <strong>Microsoft Azure</strong> gibi büyük sağlayıcılar, yenilenebilir enerji kaynaklarına ciddi yatırımlar yapıyor.</p><p>Bununla birlikte:<br> — <strong>Kaynak Paylaşımı:</strong> Daha az enerji tüketmek için fazla kaynak tahsisinden kaçınılabilir.<br> — <strong>Otomatik Ölçeklendirme:</strong> İş yüküne göre otomatik olarak “scale up- down” olan sistemler kurulabilir. Böylece gereksiz kaynaklar devre dışı kalır.</p><h4><strong>4. Kullanıcı Tarafında Optimizasyon: “Frontend’in Günahları”</strong></h4><p>Sadece backend değil, frontend uygulamaları da enerji tüketir. Örneğin, bir web sitesinin yükleme süresi uzadığında kullanıcı cihazları daha fazla işlem gücü ve enerji tüketir. İşte bu yüzden:<br> — <strong>Hafif Uygulamalar:</strong> Gereksiz görsellerden ve ağır JavaScript kütüphanelerinden kaçınmak gerekir.<br> — <strong>Dark Mode:</strong> Çoğu kullanıcı tarafından sevilen bir özellik olan dark mode, aynı zamanda enerji tasarrufu sağlar (özellikle OLED ekranlarda).</p><h4><strong>5. Gözlemleme ve Optimizasyon</strong></h4><blockquote><strong>“Continuous Greening”</strong> kavramını ortaya atmış olayım :)</blockquote><p>Mimarilerimizde enerji tüketimini düzenli olarak gözlemlemeliyiz. Bunun için <strong>observability toolları kullanmak gerekir</strong>:<br> — <strong>Logs:</strong> Sistem hangi durumlarda enerji tüketimini artırıyor?<br> — <strong>Metrics:</strong> Hangi mikroservis ne kadar kaynak tüketiyor?<br> — <strong>Traces:</strong> Verinin sistem içinde gereksiz yere dolaşıp dolaşmadığını tespit etmeyi sağlar.</p><blockquote>Unutmayalım ki, ölçemediğimiz şeyi geliştiremeyiz.</blockquote><h4><strong>Doğa İçin Küçük, Gelecek İçin Büyük Adımlar</strong></h4><p>Yeşil yazılım mimarisi, belki doğayı kurtarmanın tek başına bir yolu değil, ama önemli bir başlangıç. Hepimiz bu konuda üzerimize düşeni yaparsak, sadece daha verimli sistemler değil, geleceğe daha yaşanabilir bir gezegen de bırakabiliriz.</p><p>Son olarak, bir gün o hayalim gerçekleşirse sizi mutlaka “orman yazılım evi”me davet edeceğim. Ama şimdilik, teknolojiyi daha yeşil hale getirmek için hep birlikte çalışmaya devam edelim. Unutmayın, küçük değişiklikler büyük etkiler yaratabilir!</p><p><strong>Doğayı sev, kodu optimize et.</strong>😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=948ed3907607" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dependency Hell: .NET Perspektifinden Kodunuzun Kaynanası ve 13 Tencere Teflon Sorunu]]></title>
            <link>https://medium.com/@mumin.varici/dependency-hell-net-perspektifinden-kodunuzun-kaynanas%C4%B1-ve-13-tencere-teflon-sorunu-310acbc0df28?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/310acbc0df28</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[aspnetcore]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Thu, 26 Dec 2024 23:34:15 GMT</pubDate>
            <atom:updated>2026-11-15T05:26:34.360Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1RbeRuLF1RF3Pk_zjf_rkA@2x.jpeg" /><figcaption>Photo by Devin H on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Bağımlılıklar (dependencies), yazılım geliştirme dünyasının vazgeçilmez bir parçasıdır. Ama bu vazgeçilmezler bazen başımıza dert olur. .NET ekosisteminde de bağımlılık yönetimi, geliştiricilerin en çok uğraştığı konulardan biridir. Tıpkı evliliğinizin mutlu mesut sürdüğünü düşünürken kaynananızın aniden uzun süreli bir misafirliğe gelmesi gibi… İşler bir anda karmaşıklaşır ve düzene sokması çok daha zor bir hâl alır.</p><p>Hazırsanız, bu yazıda Dependency Hell’i, .NET projelerinde nasıl ortaya çıktığını, mutfak analojileriyle detaylandırıp ele alacağız. Hadi gelin, kodunuzun kaynanasını tanıyalım!</p><h3>Dependency Hell Nedir? (.NET’teki Yansıması)</h3><p>Dependency Hell, bir yazılım projesinde kullanılan bağımlılıkların birbirleriyle uyumsuz hâle gelmesidir. Bu problem genelde şu durumlarda ortaya çıkar:</p><p>1.	Birden fazla bağımlılığın farklı sürümleri arasında çatışma yaşanır.</p><p>2.	Transitif bağımlılıklar (başka bir bağımlılığın ihtiyaç duyduğu bağımlılıklar) arasında versiyon uyumsuzluğu oluşur.</p><p>3.	Kendi projenizde bir bağımlılık güncellendiğinde, zincirleme bir şekilde diğer bağımlılıkların bozulmasına neden olur.</p><h3>.NET’teki Örnek Durum</h3><p>Bir .NET projesinde, NuGet paketleri üzerinden bağımlılıklarınızı eklediğinizi düşünelim.</p><p>• Projenizde Newtonsoft.Json 12.0.3 sürümünü doğrudan referans ediyorsunuz.</p><p>• Aynı zamanda kullandığınız başka bir NuGet paketi ise Newtonsoft.Json’un en az 13.0.2 sürümünü istiyor.</p><p>•	Sonuç? NuGet size şu hata mesajını atar:</p><pre>NU1605: Detected package downgrade: Newtonsoft.Json from 13.0.2 to 12.0.3. </pre><p>Bu, kaynananızın size “Bu yeni tencere çok ince olmuş, ben eski düdüklümü kullanırım,” demesiyle aynı şeydir. Yani sizin modern ihtiyaçlarınıza ayak uydurmaz ve eski düzene sadık kalmak ister.</p><h3>Dependency Hell Neden Ortaya Çıkar?</h3><h4>1.	Bağımlılık Çakışmaları</h4><p>.NET projelerinde, bir NuGet paketi genellikle başka paketlere bağımlıdır. Ancak bu bağımlılıklar farklı sürümler gerektiriyorsa, proje derleme sırasında hata verir. Bu, mutfakta aynı yemek için iki farklı tarif kullanan iki kişinin sürekli tartışmasına benzer.</p><h4>2.	Transitif Bağımlılıklar</h4><p>Bir bağımlılığın kullandığı başka bağımlılıklar varsa, işler daha da karmaşık hâle gelir. Örneğin:</p><p>•	Projeniz A kütüphanesini kullanır.</p><p>•	A, B ve C kütüphanelerine ihtiyaç duyar.</p><p>•	Ancak B ve C, aynı bağımlılığın (örneğin D) farklı sürümlerini talep eder.</p><p>Bu durumda, NuGet hangi sürümü kullanacağına karar veremeyebilir ve sizi uzun bir hata listesiyle baş başa bırakır.</p><h4>3.	Güncelleme Problemleri</h4><p>Bir bağımlılığın yeni bir sürümünü kullanmak istersiniz, ancak bu güncelleme diğer paketlerin çalışmasını bozar. Örneğin:</p><p>•	Entity Framework Core 7 kullanıyorsunuz, ancak bu sürüm, kullandığınız bir başka paketin eski sürümüyle uyumsuz.</p><p>•	“Yeni EF Core harika görünüyor, neden kullanmayayım ki?” dersiniz. Ama diğer kütüphaneler adeta kaynananız gibi tepki verir: “Ben bu yeniliklere ayak uyduramam!”</p><h3>Dependency Hell’in .NET Projelerine Zararları</h3><p>Dependency Hell, sadece zaman kaybına neden olmaz; aynı zamanda projenizi uzun vadede sürdürülemez bir hâle getirir:</p><p>•	Derleme Hataları: NuGet bağımlılıkları çözemez ve projeniz derlenemez.</p><p>•	Production Ortamı Problemleri: Farklı bağımlılık versiyonları nedeniyle test ortamında çalışan bir kod, üretimde beklenmedik hatalar verebilir.</p><p>•	Kod Karmaşıklığı: Transitif bağımlılıklar ve uyumsuz sürümler, kodunuzu anlamayı ve yönetmeyi zorlaştırır.</p><h3>Mutfak Analojisi: .NET’teki Bağımlılık Yönetimi</h3><p>Kodunuzu bir mutfak, bağımlılıkları da mutfak eşyaları olarak düşünelim. Her şey düzenli ve uyumlu olmalı ki işler yolunda gitsin. Ancak Dependency Hell ortaya çıktığında, mutfağınız şu duruma dönüşebilir:</p><p>•	Versiyon Çatışmaları: Eski tencere yeni ocağa uymuyor. Kaynananızın getirdiği eski düdüklü tencereyi kullanmaya çalışıyorsunuz ama ocağınızın otomatik kapak kilidi devreye giriyor.</p><p>•	Transitif Bağımlılıklar: Kaynananızın “Bunu kullan” dediği tencerenin kapağı, sizin kullandığınız diğer bir tencerenin altına dönüştürülemiyor.</p><p>•	Güncelleme Problemleri: Yeni bir mikser alıyorsunuz ama eski blender bıçağı buna uymuyor. Sonuç? Çöpe giden yemek ve boşa harcanan zaman.</p><h3>.NET Perspektifinden Dependency Hell’den Kurtulma Yolları</h3><h4>1. NuGet Paketlerini Akıllıca Yönetmek</h4><p>.NET dünyasında bağımlılık yönetiminin anahtarı, NuGet paketlerini doğru kullanmaktır.</p><p>•	NuGet paketleri için belirli sürüm numaralarını kilitleyin (PackageReference ile Version özelliğini kullanarak).</p><p>• Transitif bağımlılıkları görmek için dotnet list package --include-transitive komutunu çalıştırarak hangi paketlerin zincirde olduğunu kontrol edin.</p><h4>2. Bağımlılıkları Minimumda Tutun</h4><p>Gereksiz kütüphaneleri projeye dahil etmeyin. Örneğin, sadece birkaç JSON işlemi için hem Newtonsoft.Json hem de System.Text.Json kullanmak yerine, birini seçin. Mutfakta iki farklı düdüklü tencereyle yemek yapmaya çalışmak size sadece baş ağrısı getirir.</p><h4>3. Paket Çakışmalarını Çözmek için Assembly Redirect Kullanın</h4><p>.NET Framework projelerinde çakışmaları çözmek için bindingRedirect özelliğini kullanabilirsiniz. Modern .NET (Core ve sonrası) projelerinde binding redirect gerekmez; çakışan transitif paketi PackageReference ile doğrudan istediğiniz sürüme sabitlemek ya da Central Package Management (Directory.Packages.props) ile sürümleri tek yerden yönetmek daha sağlıklı bir yoldur.</p><h4>4. Paket Güncellemelerini Test Edin</h4><p>Bağımlılık güncellemelerini doğrudan production ortamına taşımayın. Bunun yerine, CI/CD pipeline’ınıza paket güncellemeleri için bir test adımı ekleyin.</p><h4>5. Kendi Kütüphanelerinizi Yazın</h4><p>Eğer bir bağımlılık sürekli sorun çıkarıyorsa ve sıkça kullandığınız basit bir işlemi içeriyorsa, o işlevi kendi kodunuzda uygulamayı düşünün. Tıpkı kaynananızın sürekli eleştirdiği kek tarifini alıp kendi tarzınızla yapmanız gibi.</p><h3>Son Söz: .NET Projelerinizde Huzur Sağlamak</h3><p>Dependency Hell, yazılım projelerinin kaçınılmaz bir gerçeğidir. Ancak doğru stratejilerle, bu karmaşıklığı yönetmek mümkün. Unutmayın, .NET projelerinde bağımlılık yönetimi, sadece kodunuzu değil, aynı zamanda işinizi de uzun vadede etkiler.</p><p>Sonuç olarak, kodunuzun mutfağına hâkim olun. Tencerelerinizi (bağımlılıklarınızı) düzenli tutun, yeni bir araç (kütüphane) eklemeden önce ihtiyaçlarınızı doğru analiz edin ve kaynananızın (bağımlılıklarınızın) işlerinizi sabote etmesine izin vermeyin!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=310acbc0df28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comparison of Monolithic and Microservices Architecture: Why Monolithic Systems Can Still Be…]]></title>
            <link>https://medium.com/@mumin.varici/comparison-of-monolithic-and-microservices-architecture-why-monolithic-systems-can-still-be-03cd7aac7326?source=rss-9586ba92fd67------2</link>
            <guid isPermaLink="false">https://medium.com/p/03cd7aac7326</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[saga]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Mümin Kadir Varıcı]]></dc:creator>
            <pubDate>Sat, 26 Oct 2024 23:41:54 GMT</pubDate>
            <atom:updated>2024-10-26T23:41:54.584Z</atom:updated>
            <content:encoded><![CDATA[<h3>Comparison of Monolithic and Microservices Architecture: Why Monolithic Systems Can Still Be Preferred, Even with the Saga Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sw2SIhHtx_jZHRMXApNZHA.png" /></figure><p>Software architecture continues to evolve as technology advances and business needs diversify. In recent years, microservices architecture has become a popular solution, offering flexibility and scalability. However, the complexity of microservices and the management of distributed systems can make <strong>transactional monolithic services</strong> an attractive choice in certain cases. In this article, we will compare <strong>monolithic and microservices architecture</strong>, using the example of <strong>paying a credit card debt in TL (Turkish Lira) from a USD foreign currency account</strong>. We will also explore the role of the <strong>Saga Pattern</strong> in microservices and discuss why monolithic structures may still be preferred in some scenarios.</p><p>Before we start; We are not giving up on microservice architecture :)</p><p>Enjoy it!</p><h4>Microservices Architecture and Distributed Transactions</h4><p>Microservices divide different functionalities of a system into independent services, each with its own lifecycle. This structure is preferred for the flexibility, scalability, and faster development cycles it provides. However, one of the biggest challenges of microservices is <strong>distributed transactions</strong>. For example, the process of paying a credit card debt in TL(Turkish Lira) using a USD foreign currency account involves coordinating multiple services:</p><ol><li><strong>USD Account Service</strong>: Withdraws money from the customer’s USD account.</li><li><strong>Credit Card Service</strong>: Pays off the TL credit card debt.</li><li><strong>Currency Exchange Service</strong>: Retrieves the current USD/TRY exchange rate.</li></ol><p>Each service operates its own database, and managing the entire process requires handling distributed transactions. This is where the <strong>Saga Pattern</strong> comes in.</p><p>What is the Saga Pattern?</p><p>The Saga Pattern is used to manage a transaction across multiple microservices, completing it step by step and providing compensating actions in case of failures. In the example mentioned above:</p><ul><li>In the first step, the money is withdrawn from the USD account and converted to TL to pay the credit card debt.</li><li>If something goes wrong (like a problem retrieving the exchange rate), previous steps are undone (the money is refunded to the USD account).</li></ul><p>While this model tries to maintain consistency in a distributed environment, using the Saga Pattern can still lead to challenges, especially in complex business logic.</p><h3>Drawbacks of Saga Pattern and Microservices</h3><h4>1. Complexity in Distributed Transactions</h4><p>Although the Saga Pattern helps coordinate steps between microservices and manage failures, it brings complexity to systems where business processes are already intricate. Each microservice must not only handle its own task but also manage error scenarios. For example:</p><ul><li>The USD account service may successfully withdraw money, but if there is an error in the currency exchange or credit card service, all steps need to be rolled back.</li><li>These rollback processes must be managed for each microservice individually, which increases the overall complexity of the system.</li></ul><h4>2. Data Inconsistency and Lack of Atomicity</h4><p>In distributed transactions, ensuring consistency between multiple microservices is challenging. Since each service has its own database, transactions can’t be completed atomically (all or nothing). Although the Saga Pattern helps manage this, there is no guarantee that all steps will always succeed or fail completely. For instance:</p><ul><li>The money could be withdrawn from the USD account, but due to an error in the currency exchange service, the credit card debt may not be paid.</li><li>This can lead to temporary inconsistencies, which are a common issue in distributed systems.</li></ul><h4>3. Performance and Monitoring Challenges</h4><p>Tracking performance and debugging issues in distributed systems are much more difficult than in monolithic architectures. In the Saga Pattern, each step of the process needs to be monitored, and problems at any stage can affect the entire transaction. This can lead to performance issues and difficulties in identifying where the problem occurred. For example:</p><ul><li>Coordinating multiple services like USD account, currency exchange, and credit card payment can extend the transaction time.</li><li>Monitoring where the transaction failed in a distributed environment can be complex and costly.</li></ul><h3>Why Monolithic Systems May Still Be Preferred, Even with Saga Pattern</h3><p>Considering the challenges mentioned above, <strong>monolithic architectures</strong> may be a better option for some cases. Here are a few reasons why transactional monolithic systems are still preferred:</p><h4>1. Transaction Atomicity and Consistency (with Distributed Transaction Management)</h4><p>In a monolithic architecture, managing distributed transactions across multiple databases can still be done using <strong>distributed transaction management</strong> techniques like <strong>Two-Phase Commit (2PC)</strong> or <strong>XA Transactions</strong>. For example:</p><ul><li>When withdrawing money from a USD account and paying off a TL credit card debt, these actions can occur in separate databases, but within a single distributed transaction.</li><li>A <strong>Transaction Coordinator</strong> ensures that all databases involved in the transaction are either successfully updated or rolled back together, maintaining atomicity and consistency.</li></ul><h4>2. Less Complexity</h4><p>Monolithic architectures are generally less complex because all processes are managed within a single application. In the case of USD to TL credit card payments, all steps are coordinated under a single system, avoiding the need for distributed transaction management tools like the Saga Pattern. For instance:</p><ul><li>With all steps occurring within one transaction, there is no need to manage rollback actions across multiple services.</li><li>This reduces the overall system complexity and makes it easier to maintain and debug.</li></ul><h4>3. Performance Advantages</h4><p>Monolithic systems, which operate on a single application and often a single database, typically have better performance for transactional operations compared to microservices. Coordinating multiple services in a distributed system can slow down the process. In performance-critical scenarios, a monolithic structure can be more efficient.</p><h3>Conclusion</h3><p>While microservices architecture offers many advantages in terms of flexibility and scalability, the complexity of managing distributed transactions, data inconsistency, and performance issues can make monolithic systems a better choice in some cases. Especially for <strong>transactional processes</strong>, the <strong>atomicity, consistency, and performance</strong> offered by monolithic architectures should not be overlooked.</p><p>Even in a monolithic setup, with multiple databases involved, distributed transaction management can ensure that all processes are coordinated smoothly. In cases where process simplicity, transaction security, and atomicity are critical, monolithic architectures may still provide a powerful alternative.</p><p>In conclusion, selecting the right architecture depends on the specific business needs and the complexity of the operations involved.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=03cd7aac7326" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>