<?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 Doğukan Güney@HepsiBurada on Medium]]></title>
        <description><![CDATA[Stories by Doğukan Güney@HepsiBurada on Medium]]></description>
        <link>https://medium.com/@dogukanguney?source=rss-2bb590437730------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*hnRlHE0ObhsJQbdav1APPA.jpeg</url>
            <title>Stories by Doğukan Güney@HepsiBurada on Medium</title>
            <link>https://medium.com/@dogukanguney?source=rss-2bb590437730------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 16:14:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dogukanguney/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[Nesne Yönelimli Programlama: Trilyon Dolarlık Felaket (Türkçe Çeviri)]]></title>
            <link>https://medium.com/@dogukanguney/nesne-y%C3%B6nelimli-programlama-trilyon-dolarl%C4%B1k-felaket-t%C3%BCrk%C3%A7e-%C3%A7eviri-087d30c63377?source=rss-2bb590437730------2</link>
            <guid isPermaLink="false">https://medium.com/p/087d30c63377</guid>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Doğukan Güney@HepsiBurada]]></dc:creator>
            <pubDate>Wed, 18 Dec 2024 11:20:45 GMT</pubDate>
            <atom:updated>2024-12-18T12:31:11.655Z</atom:updated>
            <content:encoded><![CDATA[<h3>Neden OOP’yi Geride Bırakma Zamanı Geldi?</h3><p>Nesne Yönelimli Programlama (Object-Oriented Programming — OOP), birçok kişi tarafından bilgisayar biliminin taç mücevheri olarak görülüyor. Kod organizasyonu için nihai çözüm. Tüm sorunlarımızın sonu. Programlarımızı yazmanın tek doğru yolu. Programlamanın yüce tanrısı tarafından bize bahşedilen bir armağan…</p><p>Ta ki işler böyle olmadığı anlaşılana kadar. İnsanlar, soyutlamaların ağırlığı altında ezilmeye başlıyor ve düzensizce paylaşılan değiştirilebilir nesnelerin karmaşık grafikleri arasında kayboluyor. Değerli zaman ve zihinsel enerji, gerçek dünya problemlerini çözmek yerine “soyutlamalar” ve “tasarım kalıpları” hakkında düşünmeye harcanıyor.</p><p>Nesne Yönelimli Programlama, çok sayıda kişi tarafından eleştirilmiştir. Bunların arasında oldukça tanınmış yazılım mühendisleri de var. Hatta, OOP’nin mucidi bile modern OOP’nin iyi bilinen bir eleştirmenidir!</p><p>Bir yazılım geliştiricisinin nihai hedefi, güvenilir kod yazmak olmalıdır. Kod hatalı ve güvensizse başka hiçbir şeyin önemi yoktur. Peki, güvenilir kod yazmanın en iyi yolu nedir? <strong>Basitlik.</strong> Basitlik, karmaşıklığın zıttıdır. Bu nedenle, yazılım geliştiricileri olarak öncelikli sorumluluğumuz, kod karmaşıklığını azaltmak olmalıdır.</p><h3>Uyarı</h3><p>Açık konuşmak gerekirse, Nesne Yönelimli Programlama (OOP) konusunda büyük bir hayran değilim. Bu makalenin tarafsız olmayacağı açık; ancak OOP’yi sevmemek için iyi nedenlerim var.</p><p>OOP eleştirisinin çok hassas bir konu olduğunu da biliyorum — bu yazıyla birçok okuyucuyu rahatsız etmem muhtemel. Ancak, doğru olduğuna inandığım şeyi yapıyorum. Amacım kimseyi incitmek değil, OOP’nin neden olduğu sorunlara dikkat çekmek.</p><p>Burada Alan Kay’in OOP’sini eleştirmiyorum — kendisi bir dahi. Keşke OOP, onun tasarladığı şekilde uygulanmış olsaydı. Benim eleştirdiğim, modern Java ve C# yaklaşımıyla uygulanan OOP’dir.</p><h3>OOP’nin Varsayılan Standart Olarak Görülmesi Yanlış</h3><p>Nesne Yönelimli Programlama’nın (OOP), birçok kişi tarafından — hatta üst düzey teknik pozisyonlarda bulunanlar da dahil — kod organizasyonu için <strong>varsayılan standart</strong> olarak kabul edilmesini doğru bulmuyorum. Bunun yanında, birçok ana akım programlama dilinin OOP dışında herhangi bir kod organizasyonu alternatifi sunmaması da kabul edilemez bir durum.</p><p>Zamanında, OOP projelerinde çalışırken ben de çok zorlandım. Üstelik neden bu kadar zorlandığımı anlamıyordum. <strong>Belki yeterince iyi değildim?</strong> Birkaç tasarım kalıbı daha öğrenmem gerekiyordu diye düşündüm. Ancak sonunda tamamen tükenmişlik yaşadım.</p><p>Bu yazı, benim <strong>Nesne Yönelimli Programlama’dan Fonksiyonel Programlama’ya</strong> uzanan, birinci elden deneyimlediğim on yıllık yolculuğumun bir özetidir. Ne yazık ki, artık OOP için kullanım alanları bulmakta zorlanıyorum. Şahsen, <strong>aşırı karmaşık hale geldikleri için sürdürülemez olan OOP projelerinin başarısız olduğunu</strong> birçok kez gördüm.</p><blockquote>“Nesne yönelimli programlar, doğru olanlara alternatif olarak sunulur…”</blockquote><blockquote>— <strong>Edsger W. Dijkstra</strong>, bilgisayar biliminin öncüsü</blockquote><h3>Nesne Yönelimli Programlama: Amacını Yitiren Bir Yaklaşım</h3><p>Nesne Yönelimli Programlama (OOP), tek bir amaçla yaratıldı: <strong>prosedürel kod tabanlarının karmaşıklığını yönetmek.</strong> Başka bir deyişle, kod organizasyonunu geliştirmek için tasarlanmıştı. Ancak, OOP’nin düz prosedürel programlamadan daha iyi olduğuna dair nesnel ve açık bir kanıt bulunmamaktadır.</p><p><strong>Acı gerçek şu ki</strong>, OOP, tasarlandığı tek konuda başarısız oluyor. Kağıt üzerinde harika görünüyor — hayvanlar, köpekler, insanlar gibi temiz hiyerarşiler oluşturuyoruz. Ancak uygulamanın karmaşıklığı arttıkça, bu sistem çökmeye başlıyor. Karmaşıklığı azaltmak yerine, <strong>paylaşılan değiştirilebilir durumları teşvik ederek</strong> ve sayısız tasarım deseniyle ek bir karmaşıklık katmanı ekleyerek işleri daha da zorlaştırıyor. OOP, kodun yeniden yapılandırılması ve test edilmesi gibi yaygın geliştirme süreçlerini gereksiz yere zorlaştırıyor.</p><h3>Modern OOP’nin Temel Sorunları</h3><p>Bazıları bu görüşe katılmayabilir, ancak modern Java/C# OOP’nin hiçbir zaman düzgün bir şekilde tasarlanmadığı gerçeği değişmez. OOP, sağlam bir araştırma kurumundan çıkmış bir yaklaşım değildir (Haskell veya Fonksiyonel Programlama’nın aksine). Lambda hesabı, Fonksiyonel Programlama için tam bir teorik temel sunar. <strong>OOP’nin bununla eşleşecek bir teorik temeli yoktur.</strong></p><p>OOP kullanımı, kısa vadede zararsız gibi görünebilir, özellikle yeni başlayan projelerde (greenfield). Ancak, <strong>OOP’nin uzun vadeli sonuçları</strong> nelerdir? OOP bir zaman bombasıdır; kod tabanı yeterince büyüdüğünde patlamaya hazır hale gelir.</p><ul><li>Projeler gecikir.</li><li>Teslim tarihleri kaçırılır.</li><li>Geliştiriciler tükenir.</li><li>Yeni özellikler eklemek neredeyse imkansız hale gelir.</li><li>Organizasyon, kod tabanını “eski kod tabanı” (legacy codebase) olarak adlandırır ve ekibin yeniden yazma planları başlar.</li></ul><h3>İnsan Beyni ve OOP: Doğal Olmayan Bir Yaklaşım</h3><p>OOP, insan beyni için doğal bir yaklaşım değildir. Düşünce sürecimiz “bir şeyler yapmaya” odaklıdır: yürüyüşe çıkmak, bir arkadaşla konuşmak, pizza yemek. Beynimiz, dünyayı soyut nesnelerin karmaşık hiyerarşilerine ayıracak şekilde evrilmemiştir.</p><p>OOP kodu <strong>deterministik değildir</strong> — Fonksiyonel Programlama’nın aksine, aynı girdilere aynı çıktıyı alma garantimiz yoktur. Bu durum, programı anlamayı oldukça zorlaştırır.</p><p>Basit bir örnekle açıklayacak olursak: 2+2 veya calculator.Add(2, 2) işleminin sonucu genellikle dört olmalıdır. Ancak bazen bu sonuç üç, beş ya da hatta 1004 olabilir. <strong>Calculator</strong> nesnesinin bağımlılıkları, hesaplama sonucunu küçük ama derin bir şekilde değiştirebilir.</p><h3>Daha Güçlü Bir Çerçevenin Gerekliliği</h3><p>İyi programcılar iyi kod yazar, kötü programcılar kötü kod yazar — bu, programlama paradigmasından bağımsızdır. Ancak, bir programlama paradigması, kötü programcıların <strong>çok fazla hasar vermesini engelleyecek şekilde sınırlandırılmış olmalıdır.</strong> Elbette, bu kişi siz değilsiniz, çünkü şu anda bu makaleyi okuyarak öğrenmek için çaba sarf ediyorsunuz. Kötü programcıların öğrenmek için zamanı yoktur; klavyede rastgele tuşlara basmakla meşguldürler.</p><p>İster sevin ister sevmeyin, kötü programcılarla çalışmak zorunda kalacaksınız ve bazıları gerçekten çok kötü olacak. Maalesef, OOP, kötü programcıların büyük zararlara yol açmasını engelleyecek yeterli sınırlamalara sahip değildir.</p><h3>Güçlü Bir Çerçeveye Dayanmanın Önemi</h3><p>Kendimi kötü bir programcı olarak görmüyorum, ancak <strong>çalışmalarımı dayandırabileceğim güçlü bir çerçeve</strong> olmadan iyi kod yazamıyorum. Evet, bazı çok özel sorunlarla ilgilenen çerçeveler var (örneğin, Angular ya da ASP.Net). Ancak burada bahsettiğim çerçeve, yazılım çerçeveleri değil.</p><p>Daha soyut bir tanım olan şu anlamdaki çerçeveden bahsediyorum: “temel bir destek yapısı.” Yani, <strong>kod organizasyonu</strong> ve <strong>kod karmaşıklığını yönetmek</strong> gibi daha soyut konularla ilgilenen çerçeveler.</p><p>Her ne kadar Nesne Yönelimli Programlama (OOP) ve Fonksiyonel Programlama (FP) birer programlama paradigması olsalar da, aslında her ikisi de oldukça <strong>yüksek seviyeli çerçevelerdir.</strong></p><h3>Seçenekleri Sınırlamak</h3><blockquote><strong><em>C++ berbat bir dil… Projenizi sadece C ile sınırlandırmak, insanların saçma sapan “nesne modeli” zırvalıklarıyla işleri batırmasını engeller.</em></strong><em><br> — </em><strong><em>Linus Torvalds</em></strong><em>, Linux’un yaratıcısı</em></blockquote><p>Linus Torvalds, C++ ve Nesne Yönelimli Programlama (OOP) hakkındaki açık eleştirileriyle tanınır. Ancak, %100 haklı olduğu bir nokta, programcıların yapabilecekleri seçimleri sınırlamaktır. Aslında, <strong>programcıların daha az seçeneğe sahip olması, kodlarının daha dayanıklı hale gelmesini sağlar.</strong></p><p>Yukarıdaki alıntıda Linus Torvalds, kodumuzu dayandırabileceğimiz <strong>iyi bir çerçeveye sahip olmayı</strong> şiddetle tavsiye ediyor.</p><p>Birçok insan yollardaki hız limitlerinden hoşlanmaz, ancak bu sınırlar insanların ölümcül kazalardan korunması için gereklidir. Benzer şekilde, iyi bir programlama çerçevesi de bizi aptalca şeyler yapmaktan alıkoyacak mekanizmalar sağlamalıdır.</p><p>İyi bir programlama çerçevesi, güvenilir kod yazmamıza yardımcı olur. En önemlisi, şu unsurları sağlayarak karmaşıklığı azaltmalıdır:</p><ul><li><strong>Modülerlik ve tekrar kullanılabilirlik</strong></li><li><strong>Doğru bir şekilde izole edilmiş durum yönetimi</strong></li><li><strong>Yüksek sinyal-gürültü oranı</strong></li></ul><p>Ne yazık ki, OOP geliştiricilere çok fazla araç ve seçenek sunarken, doğru türden sınırlamaları getirmekte başarısız oluyor. Modülerliği ele almayı ve tekrar kullanılabilirliği artırmayı vaat etmesine rağmen, bu sözlerini yerine getiremiyor (bu konuyu daha sonra detaylandıracağız).</p><p>OOP kodu, <strong>paylaşılan değiştirilebilir durumların kullanımını teşvik eder</strong> ve bu tür bir yaklaşımın güvensiz olduğu defalarca kanıtlanmıştır. Ayrıca, OOP genellikle büyük miktarda gereksiz kod (düşük sinyal-gürültü oranı) gerektirir.</p><h3>Fonksiyonel Programlama</h3><p>Fonksiyonel Programlama tam olarak nedir? Bazı insanlar bunun yalnızca akademide uygulanabilen, gerçek dünyaya uygun olmayan, son derece karmaşık bir programlama paradigması olduğunu düşünür. Ancak bu düşünce gerçeğin tam tersi!</p><p>Evet, Fonksiyonel Programlama güçlü bir matematiksel temele sahiptir ve köklerini lambda hesaplamasından alır. Ancak, temel fikirlerinin çoğu daha yaygın programlama dillerindeki zayıflıklara bir yanıt olarak ortaya çıkmıştır. <strong>Fonksiyonlar</strong>, Fonksiyonel Programlamanın temel soyutlamasıdır. Doğru kullanıldığında, fonksiyonlar OOP’de görülmeyen bir kod modülerliği ve tekrar kullanılabilirlik seviyesi sağlar. Fonksiyonel Programlama, null değerler gibi sorunlara yönelik tasarım kalıpları içerir ve hata yönetimi için üstün bir yöntem sunar.</p><p>Fonksiyonel Programlamanın gerçekten iyi yaptığı bir şey varsa, o da <strong>güvenilir yazılımlar yazmamıza yardımcı olmasıdır.</strong> Debugger’a olan ihtiyaç neredeyse tamamen ortadan kalkar. Evet, kodunuzu adım adım izlemenize veya değişkenleri takip etmenize gerek yok. Şahsen, uzun zamandır bir debugger’a dokunmadım bile.</p><p>En iyi yanı? Zaten fonksiyonları nasıl kullanacağınızı biliyorsanız, aslında bir fonksiyonel programcı sayılırsınız. Sadece bu fonksiyonları en iyi şekilde nasıl kullanacağınızı öğrenmeniz gerekiyor!</p><p>Burada Fonksiyonel Programlamayı savunmuyorum. Kodunuzu yazarken hangi programlama paradigmasını kullandığınız umurumda değil. Sadece, Fonksiyonel Programlamanın OOP ve prosedürel programlamanın doğasında bulunan sorunları ele almak için sunduğu mekanizmaları aktarmaya çalışıyorum.</p><h3>OOP’yi Baştan Yanlış Anladık</h3><blockquote><strong><em>“Bu konu için uzun zaman önce ‘nesneler’ terimini kullandığım için üzgünüm, çünkü bu, birçok insanın daha az önemli bir fikre odaklanmasına neden oluyor. Asıl büyük fikir mesajlaşmadır.”</em></strong><em><br> — </em><strong><em>Alan Kay</em></strong><em>, OOP’nin mucidi</em></blockquote><p>Erlang genellikle Nesne Yönelimli bir dil olarak düşünülmez. Ancak muhtemelen Erlang, günümüzdeki ana akım programlama dilleri arasında gerçekten <strong>Nesne Yönelimli</strong> olan tek dildir.</p><p>Elbette, Smalltalk doğru bir OOP dilidir — ancak yaygın olarak kullanılmamaktadır. Hem Smalltalk hem de Erlang, OOP’yi Alan Kay’in orijinal olarak tasarladığı şekilde uygulayan dillerdir.</p><h3>Mesajlaşma</h3><p>Alan Kay, “Nesne Yönelimli Programlama” terimini 1960’larda ortaya attı. Biyoloji alanında bir geçmişe sahip olan Kay, bilgisayar programlarını, <strong>canlı hücrelerin birbirleriyle iletişim kurduğu şekilde</strong> haberleştirmek için tasarlamaya çalışıyordu.</p><p>Alan Kay’in büyük fikri, birbirinden bağımsız programların (hücrelerin) mesajlar göndererek iletişim kurmasıydı. Bu bağımsız programların durumu, dış dünya ile asla paylaşılmamalıydı (<strong>enkapsülasyon</strong>).</p><p>Hepsi bu kadar. OOP, hiçbir zaman miras alma (inheritance), çok biçimlilik (polymorphism), “new” anahtar kelimesi veya sayısız tasarım kalıbı gibi şeylere sahip olacak şekilde tasarlanmamıştı.</p><h3>OOP’nin En Saf Hali</h3><p>Erlang, <strong>OOP’nin en saf halidir.</strong> Daha yaygın kullanılan dillerden farklı olarak, OOP’nin özündeki fikir olan <strong>mesajlaşmaya</strong> odaklanır. Erlang’da nesneler, birbirleriyle <strong>değiştirilemez mesajlar</strong> (immutable messages) göndererek iletişim kurar.</p><p>Peki, değiştirilemez mesajların yöntem çağrılarına kıyasla üstün bir yaklaşım olduğuna dair bir kanıt var mı?</p><p><strong>Kesinlikle var!</strong> Erlang, muhtemelen dünyanın en güvenilir programlama dili. Dünya genelindeki telekomünikasyon altyapısının (dolayısıyla internetin) büyük bir kısmı Erlang ile çalışıyor. Erlang ile yazılmış bazı sistemler, <strong>%99.9999999 güvenilirlik</strong> oranına sahip (evet, doğru okudunuz — dokuz adet dokuz).</p><h3>Kod Karmaşıklığı</h3><blockquote><strong><em>“OOP etkisi altında geliştirilen dillerle yazılan yazılımlar daha uzun, daha az okunabilir, daha az açıklayıcı olur ve değiştirilmesi, bakım yapılması daha zor hale gelir.”</em></strong><em><br> — </em><strong><em>Richard Mansfield</em></strong></blockquote><p>Yazılım geliştirmede en önemli unsur, <strong>kod karmaşıklığını düşük tutmaktır.</strong> Nokta. Eğer kod tabanı yönetilemez hale gelirse, hiçbir süslü özellik bir anlam ifade etmez. Hatta %100 test kapsamına sahip olmak bile kod tabanı aşırı karmaşık ve sürdürülemez hale geldiyse hiçbir işe yaramaz.</p><p>Peki, kod tabanını karmaşık hale getiren şey nedir? Dikkate alınması gereken birçok unsur vardır, ancak benim görüşüme göre en büyük suçlular şunlardır:</p><ul><li><strong>Paylaşılan değiştirilebilir durumlar</strong></li><li><strong>Hatalı soyutlamalar</strong></li><li><strong>Düşük sinyal-gürültü oranı</strong> (çoğunlukla gereksiz boilerplate kodundan kaynaklanır)</li></ul><p>Bu unsurların hepsi, OOP’de sıkça görülen problemlerdir.</p><h3>Durumun (State) Sorunları</h3><p>Durum (state) nedir? Basitçe ifade etmek gerekirse, durum bellekte saklanan geçici verilerdir. OOP’deki değişkenleri veya alanları/özellikleri (fields/properties) düşünebilirsiniz.</p><p><strong>Emredici (imperative) programlama</strong> — buna OOP de dahildir — hesaplamayı programın durumu ve bu duruma yapılan değişiklikler üzerinden tanımlar.</p><p>Buna karşılık, <strong>bildirisel (declarative) programlama</strong> ise istenen sonuçları tanımlar ve durumdaki değişiklikleri açıkça belirtmez.</p><h3>Değiştirilebilir Durum — Zihinsel Akrobasi</h3><blockquote><strong><em>“Büyük nesne yönelimli programlar, değiştirilebilir nesnelerden oluşan büyük bir grafik oluşturdukça artan karmaşıklıkla mücadele eder. Bir yöntemi çağırdığınızda neler olacağını ve yan etkilerinin ne olacağını anlamaya ve zihninizde tutmaya çalışmak tam bir zorluktur.”</em></strong><em><br> — </em><strong><em>Rich Hickey</em></strong><em>, Clojure’un yaratıcısı</em></blockquote><p>Değiştirilebilir durum (mutable state), OOP’nin en büyük sorunlarından biridir. Bu durum, bir yöntemin çağrıldığında programın diğer bölümlerine nasıl etki edeceğini anlamayı zorlaştırır. Bu da geliştiricileri, zihinsel olarak sürekli bir <strong>akrobasi</strong> yapmaya zorlar ve programın karmaşıklığını artırır.</p><p>Durum (state) tek başına oldukça zararsızdır. Ancak, <strong>değiştirilebilir durum</strong> (mutable state) bu noktada büyük bir sorun haline gelir. Özellikle de bu durum <strong>paylaşılıyorsa</strong>.</p><p><strong>Değiştirilebilir durum nedir?</strong> Basitçe, değişebilen herhangi bir durumdur. OOP bağlamında, değişkenler veya alanlar (fields) olarak düşünebilirsiniz.</p><h4>Gerçek Dünya Örneği</h4><p>Boş bir kağıt aldığınızı düşünün. Üzerine bir not yazıyorsunuz ve sonunda aynı kağıt, üzerinde yazı bulunan farklı bir duruma geliyor. Bu, teknik olarak kağıdın durumunu değiştirmiş olmanız demek.</p><p>Gerçek dünyada bu tamamen kabul edilebilir çünkü muhtemelen başka kimse o kağıtla ilgilenmez. Ancak, bu kağıt <strong>orijinal Mona Lisa tablosu</strong> ise işler tamamen değişir.</p><h3>İnsan Beyninin Sınırları</h3><p>Peki, değiştirilebilir durum neden bu kadar büyük bir sorun? İnsan beyni, bilinen evrendeki en güçlü makine olabilir. Ancak, <strong>durumla çalışmakta gerçekten kötüdür.</strong> Bunun nedeni, çalışma belleğimizde aynı anda yalnızca yaklaşık 5 öğeyi tutabilmemizdir.</p><p>Bir kod parçasını anlamak, yalnızca kodun <strong>ne yaptığı</strong> üzerine düşünmekle sınırlı olduğunda çok daha kolaydır. Ancak, değişkenlerin kod tabanı boyunca <strong>nerelerde ve nasıl değiştiğini</strong> anlamaya çalışmak bunu inanılmaz derecede zorlaştırır.</p><p>Değiştirilebilir durumla programlama, tam anlamıyla bir <strong>zihinsel akrobasi</strong> gibidir. İki topu havada tutabilirim belki, ancak bana üç ya da daha fazla top verirseniz, hepsini kesinlikle düşürürüm. Peki, neden her iş gününde bu zihinsel akrobasiye girişmeye çalışıyoruz?</p><p>Ne yazık ki, değiştirilebilir durumun neden olduğu zihinsel yük, OOP’nin tam merkezindedir. Bir nesne üzerindeki yöntemlerin var olma amacı, o nesnenin durumunu değiştirmekten başka bir şey değildir.</p><h3>Dağınık Durum</h3><p>OOP, kod organizasyonu sorununu daha da kötüleştirerek, durumu programın her yerine <strong>dağıtır.</strong> Bu dağınık durum, çeşitli nesneler arasında <strong>rastgele ve kontrolsüz bir şekilde paylaşılır.</strong></p><h4>Gerçek Dünya Örneği</h4><p>Bir anlığına yetişkin olduğumuzu unutup, harika bir lego kamyonu yapmaya çalıştığımızı hayal edelim.</p><p>Ama bir sorun var: Kamyon parçalarının tamamı, diğer lego oyuncaklarınızın parçalarıyla rastgele karıştırılmış. Bu yetmezmiş gibi, parçalar <strong>50 farklı kutuya rastgele</strong> dağıtılmış. Ayrıca, kamyon parçalarını bir araya getirmenize izin yok — hangi parça nerede, bunu sadece aklınızda tutmanız gerekiyor ve parçaları birer birer alabilirsiniz.</p><p>Evet, o kamyonu sonunda yapabilirsiniz, ancak <strong>ne kadar zaman alacak?</strong></p><h4>Bunun Programlamayla İlgisi Nedir?</h4><p><strong>Fonksiyonel Programlama</strong>, durumu genellikle izole eder. Her zaman bir durumun nereden geldiğini bilirsiniz. Durum, farklı fonksiyonlar arasında asla dağılmaz.</p><p><strong>OOP’de ise her nesnenin kendi durumu vardır.</strong> Bir program oluştururken, üzerinde çalıştığınız tüm nesnelerin durumlarını aklınızda tutmanız gerekir.</p><p>Hayatımızı kolaylaştırmak için, kod tabanının yalnızca <strong>çok küçük bir kısmının durumla ilgilenmesi</strong> en iyisidir. Uygulamanızın çekirdek bölümleri <strong>durumsuz (stateless) ve saf</strong> olmalıdır.</p><p>Bu yaklaşım, özellikle frontend dünyasında <strong>flux pattern’in (örneğin Redux)</strong> büyük başarısının ana nedenidir.</p><h3>Rastgele Paylaşılan Durum</h3><p>Dağınık ve değiştirilebilir durumların yarattığı zorluklar yetmezmiş gibi, OOP bir adım daha ileri gidiyor!</p><h4>Gerçek Dünya Örneği</h4><p>Gerçek dünyada değiştirilebilir durum neredeyse hiçbir zaman sorun yaratmaz, çünkü durumlar gizli tutulur ve paylaşılmaz. Buna “doğru enkapsülasyon” diyebiliriz.</p><p>Bir ressam düşünün. Yeni Mona Lisa tablosu üzerinde çalışıyor. Tek başına çalışıyor, eserini bitiriyor ve şaheserini milyonlarca dolara satıyor.</p><p>Ancak, tüm bu parayla sıkılıyor ve işlerini biraz farklı yapmaya karar veriyor. Bir resim partisi düzenlemenin iyi bir fikir olacağını düşünüyor. Arkadaşları elf, Gandalf, bir polis memuru ve bir zombiyi davet ediyor. <strong>Takım çalışması!</strong></p><p>Herkes aynı anda aynı tuval üzerinde resim yapmaya başlıyor. Tabii ki hiçbir şey yolunda gitmiyor — tablo tam bir <strong>felaket!</strong></p><h4>Programlamadaki Bağlantı</h4><p>Gerçek dünyada paylaşılan değiştirilebilir durumun hiçbir mantığı yoktur. Ancak bu, tam olarak OOP programlarında olan şeydir: <strong>Durum rastgele bir şekilde çeşitli nesneler arasında paylaşılır ve her nesne bu durumu istediği gibi değiştirir.</strong></p><p>Sonuç? Kod tabanı büyüdükçe, programın nasıl çalıştığını anlamak giderek zorlaşır. Bu da, programlama sürecini inanılmaz derecede karmaşık hale getirir.</p><h3>Eşzamanlılık Sorunları</h3><p>OOP kodlarındaki <strong>rastgele paylaşılan değiştirilebilir durum</strong>, bu tür kodların paralel çalıştırılmasını neredeyse imkansız hale getirir. Bu sorunu çözmek için son derece karmaşık mekanizmalar geliştirilmiştir: <strong>thread locking</strong>, <strong>mutex</strong> ve daha birçok mekanizma.</p><p>Ancak, bu tür karmaşık yaklaşımlar kendi dezavantajlarını beraberinde getirir:</p><ul><li><strong>Deadlocklar:</strong> Birden fazla işlem birbirini beklerken sistemin durma noktasına gelmesi.</li><li><strong>Bileşen uyumsuzluğu:</strong> Kod parçalarının birlikte çalışmasının zorlaşması.</li><li><strong>Zor ve zaman alıcı hata ayıklama:</strong> Çok iş parçacıklı kodun debug edilmesi oldukça zordur.</li></ul><p>Bunlar bir yana, bu eşzamanlılık mekanizmalarının kullanımı kodun karmaşıklığını daha da artırır. OOP’nin bu temel sorunu, paralel işleme ihtiyaç duyulan uygulamalarda ciddi darboğazlar yaratır.</p><h3>Her Durum Kötü Değil</h3><p>Tüm durumlar kötü müdür? Hayır, <strong>Alan Kay’in tanımladığı şekilde bir durum muhtemelen kötü değildir!</strong> Durum değişimi, eğer gerçekten izole edilmişse (ancak <strong>OOP’nin iddia ettiği gibi değil</strong>), gayet kabul edilebilir bir yaklaşımdır.</p><p>Değiştirilemez veri aktarım nesnelerine (<strong>immutable data-transfer objects</strong>) sahip olmak da tamamen sorun değildir. Buradaki kilit nokta “<strong>değiştirilemezliktir</strong>.” Bu tür nesneler, veriyi fonksiyonlar arasında taşımak için kullanılır.</p><p>Ancak bu tür nesneler, aynı zamanda OOP’nin yöntemlerini (methods) ve özelliklerini (properties) tamamen gereksiz hale getirir. Bir nesne değiştirilemiyorsa, üzerinde yöntemlere veya özelliklere sahip olmanın ne anlamı kalır?</p><h3>Değiştirilebilirlik OOP’nin Doğasında Var</h3><p>Bazıları, OOP’deki değiştirilebilir durumun bir <strong>tasarım tercihi</strong> olduğunu, bir zorunluluk olmadığını iddia edebilir. Ancak bu argümanda bir sorun var: Bu bir tasarım tercihi değil, neredeyse tek seçenektir.</p><p>Evet, Java veya C# gibi dillerde yöntemlere değiştirilemez nesneler (<strong>immutable objects</strong>) geçirilebilir. Ancak bu nadiren yapılır çünkü çoğu geliştirici, varsayılan olarak veriyi değiştirme (data mutation) eğilimindedir. Dahası, geliştiriciler OOP programlarında değiştirilemezliği doğru bir şekilde kullanmaya çalışsalar bile, bu dillerin değiştirilemezlik için yerleşik mekanizmalar veya değiştirilemez veriyle etkin bir şekilde çalışmaya uygun kalıcı veri yapıları (<strong>persistent data structures</strong>) sunmadığı bir gerçektir.</p><p>Evet, nesnelerin yalnızca <strong>değiştirilemez mesajlar</strong> ile iletişim kurmasını ve hiçbir referans paylaşmamasını sağlayabiliriz (ki bu da nadiren yapılır). Böyle programlar, ana akım OOP’ye göre daha güvenilir olur. Ancak, nesneler yine de bir mesaj aldıklarında kendi durumlarını değiştirmek zorundadır.</p><p>Bir mesaj, bir <strong>yan etkidir</strong> ve var olma amacı, değişikliklere neden olmaktır. Mesajlar, diğer nesnelerin durumunu değiştiremiyorsa işe yaramaz hale gelir.</p><p>Sonuç olarak, OOP’yi kullanmak, durum değişimlerine neden olmadan mümkün değildir. Değiştirilebilirlik, OOP’nin temel bir parçasıdır ve bundan kaçınmak pratik olarak imkansızdır.</p><h3>Enkapsülasyonun Truva Atı</h3><p>Bize, enkapsülasyonun OOP’nin en büyük faydalarından biri olduğu söylendi. Nesnenin iç durumunu dış erişimden koruması gerektiği iddia edildi. Ancak, burada küçük bir sorun var: <strong>Bu işe yaramıyor.</strong></p><p>Enkapsülasyon, OOP’nin <strong>Truva Atı</strong>dır. Paylaşılan değiştirilebilir durum fikrini, güvenli bir şeymiş gibi göstererek satar. Enkapsülasyon, <strong>güvensiz kodun kod tabanımıza sızmasına izin verir ve hatta bunu teşvik eder.</strong> Bu durum, kod tabanının içeriden çürümesine neden olur.</p><h3>Global Durum Problemi</h3><p>Bize, <strong>global durumun tüm kötülüklerin kökü</strong> olduğu ve her ne pahasına olursa olsun kaçınılması gerektiği söylendi. Ancak, kimse enkapsülasyonun aslında <strong>yüceltilmiş bir global durum</strong> olduğunu söylemedi.</p><p>Kodun daha verimli çalışmasını sağlamak için nesneler, değerleriyle değil, referanslarıyla iletilir. İşte burada, “<strong>bağımlılık enjeksiyonu</strong>” (dependency injection) yetersiz kalır.</p><p>OOP’de bir nesne oluşturduğumuzda, bağımlılıklarına ait referansları constructor’a geçiririz. Bu bağımlılıkların da kendi iç durumları vardır. Yeni oluşturulan nesne, bu bağımlılıkların referanslarını kendi iç durumunda saklar ve onları dilediği gibi değiştirmekte özgürdür. Ayrıca, bu referansları kullandığı başka bileşenlere de geçirir.</p><p>Sonuç olarak, <strong>rastgele paylaşılan nesnelerden oluşan karmaşık bir grafik</strong> ortaya çıkar. Bu nesneler birbirlerinin durumlarını sürekli olarak değiştirebilir. Bu durum, programın durumunun neden değiştiğini anlamayı neredeyse imkansız hale getirir.</p><p>Böyle bir durum değişikliğini debug etmek için günlerce uğraşabilirsiniz. Bu kadar şanslıysanız, işin içinde <strong>eşzamanlılık</strong> problemleri olmadığını umabilirsiniz (bu konuya daha sonra değineceğiz).</p><p>Enkapsülasyonun yol açtığı bu karmaşıklık, OOP’nin en büyük sorunlarından biridir.</p><h3>Method’lar /Property’ler</h3><p>Belirli alanlara erişim sağlayan methodlar veya property’ler, doğrudan bir alanın değerini değiştirmekten daha iyi değildir. Bir nesnenin durumunu süslü bir method veya property ile değiştirip değiştirmediğinizin hiçbir önemi yoktur — <strong>sonuç aynı olur: değiştirilen bir durum.</strong></p><h3>Gerçek Dünya Modelleme Sorunu</h3><p>Bazı insanlar, OOP’nin gerçek dünyayı modellemeye çalıştığını söyler. Bu tamamen yanlıştır — <strong>OOP’nin gerçek dünyayla hiçbir bağlantısı yoktur.</strong> Programları nesneler olarak modellemeye çalışmak, muhtemelen OOP’nin yaptığı en büyük hatalardan biridir.</p><h3>Gerçek Dünya Hiyerarşik Değildir</h3><p>OOP, her şeyi bir nesne hiyerarşisi olarak modellemeye çalışır. Ancak, <strong>gerçek dünyada işler böyle yürümez.</strong> Gerçek dünyadaki nesneler, birbirleriyle mesajlar yoluyla iletişim kurar ancak genellikle birbirlerinden bağımsızdır.</p><h4>Gerçek Dünyada Inheritance</h4><p>OOP’nin inheritance kavramı gerçek dünyadan esinlenmemiştir. <strong>Gerçek dünyadaki parent nesneler, çalışma zamanında child nesnelerin davranışlarını değiştiremez.</strong></p><p>Örneğin, DNA’nızı parent’larınızdan miras alırsınız, ancak parent’larınız DNA’nızı istedikleri gibi değiştiremez. Davranışlarınızı parent’larınızdan miras almazsınız; kendi davranışlarınızı geliştirirsiniz. Aynı şekilde, parent’larınızın davranışlarını override edemezsiniz.</p><h4>Gerçek Dünyada Method Yok</h4><p>Üzerine yazı yazdığınız kağıdın bir “write” method’u var mı? <strong>Hayır!</strong> Boş bir kağıt alırsınız, bir kalem seçersiniz ve yazı yazarsınız. Siz bir kişi olarak da “write” method’una sahip değilsiniz — yazı yazma kararını dış dünyadaki olaylara veya kendi iç düşüncelerinize göre alırsınız.</p><h4>İsimler Krallığı</h4><blockquote>Nesneler, function ve data structure’ları bölünemez birimler halinde birbirine bağlar. Bu, bence temel bir hatadır, çünkü function ve data structure tamamen farklı dünyalara aittir.</blockquote><blockquote>— <strong>Joe Armstrong</strong>, Erlang’in yaratıcısı</blockquote><p>Nesneler (veya isimler) OOP’nin merkezindedir. OOP’nin temel sınırlamalarından biri, her şeyi isimlere (nouns) zorlamasıdır. Ancak her şey isimlerle modellenmemelidir. İşlemler (functions), nesneler olarak modellenmemelidir. Örneğin, yalnızca iki sayıyı çarpan bir fonksiyona ihtiyacımız varken neden bir <strong>Multiplier</strong> class’ı oluşturmak zorundayız? Basitçe bir <strong>Multiply</strong> function kullanın; veri veri olarak kalsın, fonksiyonlar da fonksiyon olarak.</p><p>OOP olmayan dillerde, veriyi bir dosyaya kaydetmek gibi basit şeyleri yapmak son derece doğrudur — tıpkı İngilizce’de bir eylemi tanımlamak gibi basit ve sezgiseldir.</p><h4>Gerçek Dünya Örneği</h4><p>Bir önceki ressam örneğine geri dönelim. Bu kez ressamın bir <strong>PaintingFactory</strong>’si olduğunu düşünelim. Ayrıca bir <strong>BrushManager</strong>, <strong>ColorManager</strong>, <strong>CanvasManager</strong> ve bir <strong>MonaLisaProvider</strong> işe almış olsun. Ressamın yakın arkadaşı zombi ise bir <strong>BrainConsumingStrategy</strong> kullanıyor.</p><p>Bu nesneler de şu method’ları tanımlıyor: <strong>CreatePainting</strong>, <strong>FindBrush</strong>, <strong>PickColor</strong>, <strong>CallMonaLisa</strong> ve <strong>ConsumeBrainz</strong>.</p><p>Tabii ki bu tamamen saçmalık ve gerçek dünyada asla böyle bir şey olmaz. Basit bir resim çizme eylemi için ne kadar gereksiz bir karmaşıklık yaratılmış, farkında mısınız?</p><p>Fonksiyonlar, nesnelerden ayrı olarak var olmasına izin verildiğinde, bu tür tuhaf konseptleri icat etmeye gerek kalmaz.</p><h3>Unit Testing</h3><p>Otomatik testler, geliştirme sürecinin önemli bir parçasıdır ve mevcut koda yeni hataların (regression) eklenmesini önlemede büyük rol oynar. <strong>Unit Testing</strong>, otomatik test sürecinde kritik bir yere sahiptir.</p><p>Bazıları farklı düşünebilir, ancak OOP kodlarını <strong>unit test</strong> etmek kötü bir şöhrete sahiptir; yani, oldukça zordur. <strong>Unit Testing</strong>, bir şeyi izole bir şekilde test etmeyi varsayar. Bir method’u <strong>unit testable</strong> hale getirmek için şunları yapmanız gerekir:</p><ul><li>Bağımlılıklarını ayrı bir sınıfa taşımak.</li><li>Yeni oluşturulan sınıf için bir interface oluşturmak.</li><li>Yeni sınıfın bir örneğini tutacak alanlar (fields) tanımlamak.</li><li>Bağımlılıkları taklit etmek için bir mocking framework kullanmak.</li><li>Bağımlılıkları enjekte etmek için bir dependency-injection framework kullanmak.</li></ul><p>Peki, bir kod parçasını test edilebilir hale getirmek için ne kadar fazla karmaşıklık yaratılıyor? Sadece test edilebilirlik sağlamak için ne kadar zaman boşa harcanıyor?</p><blockquote><strong><em>Not:</em></strong><em> Bir method’u test etmek için tüm sınıfı örneklemek zorunda kalırız. Bu durum, parent sınıflarının kodlarını da beraberinde getirir.</em></blockquote><p>OOP ile eski (legacy) kodlar için test yazmak çok daha zordur — neredeyse imkansızdır. Eski OOP kodlarını test etmekle ilgili sorunlar nedeniyle, tamamen bu konuya odaklanan şirketler bile ortaya çıkmıştır (örneğin, <strong>TypeMock</strong>).</p><h4>Boilerplate Code</h4><p><strong>Boilerplate code</strong>, sinyal-gürültü oranı söz konusu olduğunda en büyük sorunlardan biri olabilir. Bu tür kod, programın derlenmesi için gerekli olan <strong>“gürültü”</strong> olarak tanımlanabilir. Boilerplate code yazmak zaman alır ve kod tabanına gereksiz gürültü ekleyerek okunabilirliği azaltır.</p><p>OOP’de sıkça tavsiye edilen <strong>“bir implementasyona değil, bir interface’e program yap”</strong> yaklaşımı her durumda uygulanabilir değildir. Ancak, test edilebilirlik amacıyla tüm kod tabanında interface kullanmak zorunda kalabiliriz. Bu durum, dependency injection kullanımını gerektirebilir ve kod tabanına daha fazla gereksiz karmaşıklık ekler.</p><h4>Private Methods’in Test Edilmesi</h4><p>Bazı insanlar, <strong>private methods</strong>’un test edilmemesi gerektiğini söyler. Ancak buna katılmıyorum. <strong>Unit Testing</strong>, küçük kod birimlerini izole bir şekilde test etmek anlamına gelir. Ancak OOP’de <strong>private methods</strong>’u test etmek neredeyse imkansızdır. Test edilebilirlik uğruna private methods’ları <strong>internal</strong> yapmak doğru bir yaklaşım değildir.</p><p>Private methods’ların test edilebilirliğini sağlamak için, genellikle bu method’ların ayrı bir nesneye taşınması gerekir. Bu da gereksiz bir karmaşıklık ve daha fazla <strong>boilerplate code</strong> eklenmesine yol açar.</p><h4>Refactoring</h4><p>Refactoring, bir geliştiricinin günlük işlerinin önemli bir parçasıdır. Ne var ki, <strong>OOP kodunu refactor etmek kötü bir üne sahiptir; oldukça zordur.</strong> Refactoring, kodun karmaşıklığını azaltmayı ve daha kolay bakım yapılabilir hale getirmeyi amaçlar. Ancak OOP kodunda durum tam tersidir — refactoring sonucunda kod daha karmaşık hale gelir.</p><p>Kodun test edilebilirliğini sağlamak için dependency injection kullanmamız, refactor edilen sınıf için bir interface oluşturmamız gerekir. Bu işlemler bile kodu refactor etmeyi kolaylaştırmaz; bunun için <strong>Resharper</strong> gibi özel araçlara ihtiyaç duyulur.</p><h4>Basit Bir Örnek</h4><p>Tek bir method’u çıkarmak için refactor edilen bir OOP kodunda satır sayısı <strong>iki katına çıkabilir.</strong> Peki, karmaşıklığı azaltmak için yapılan bir işlem neden daha fazla karmaşıklık yaratır?</p><p>Bunu, benzer bir refactor işlemini JavaScript gibi OOP olmayan bir dilde yapmayla karşılaştıralım:</p><ul><li>Kod aslında aynı kalır.</li><li>Sadece isValidInput fonksiyonunu başka bir dosyaya taşırız ve bu fonksiyonu import etmek için bir satır ekleriz.</li><li>Test edilebilirlik için _isValidInput&#39;ı fonksiyon imzasına ekleriz.</li></ul><p>Kodun yapısı basit ve doğrudan kalır. Ancak OOP’de refactoring, kod büyüdükçe <strong>karmaşıklığı üstel olarak artırır.</strong></p><h4>Refactoring’in Riskleri</h4><p>OOP kodunu refactor etmek aynı zamanda son derece risklidir. Karmaşık bağımlılık grafikleri ve kod tabanına dağılmış durumlar, insan beyninin tüm potansiyel sorunları göz önünde bulundurmasını imkansız hale getirir. Bu da refactoring sürecini hata yapmaya açık ve zorlu bir hale getirir.</p><h4>Geçici Çözümler</h4><p>Bir şey çalışmadığında ne yaparız? Cevap basittir: Ya onu atarız ya da düzeltmeye çalışırız. Ancak OOP, kolayca atılabilecek bir şey değildir. Milyonlarca geliştirici OOP üzerine eğitim almıştır ve dünya genelinde milyonlarca organizasyon OOP kullanmaktadır.</p><p>Muhtemelen artık fark ediyorsunuz ki <strong>OOP gerçekten de işe yaramıyor.</strong> Kodumuzu karmaşık ve güvensiz hale getiriyor. Ve bu düşüncede yalnız değilsiniz! İnsanlar, onlarca yıldır OOP kodlarında yaygın olan sorunları çözmeye çalışıyor. Bunun sonucunda, sayısız <strong>tasarım kalıbı (design pattern)</strong> ortaya çıkmıştır.</p><h4>Design Patterns</h4><p>OOP, geliştiricilere sistemleri adım adım büyütebilmeleri için teorik olarak bir dizi yönerge sunar: <strong>SOLID prensipleri, dependency injection, design patterns</strong> ve diğerleri.</p><p>Ne yazık ki, <strong>design patterns sadece geçici çözümlerdir.</strong> OOP’nin eksikliklerini gidermek dışında bir amaçları yoktur. Bu konu üzerine sayısız kitap yazılmıştır. Ancak bu kalıplar, kod tabanlarına büyük bir karmaşıklık ekleyerek işleri daha da zorlaştırmasaydı, belki de o kadar kötü olmayabilirlerdi.</p><h4>Problem Fabrikası</h4><p>Aslında, <strong>iyi ve sürdürülebilir Nesne Yönelimli bir kod yazmak imkansızdır.</strong></p><p>Spektrumun bir ucunda, standartlara uymayan ve tutarsız bir OOP kod tabanı bulunur. Diğer uçta ise aşırı karmaşık, birbiri üzerine inşa edilmiş hatalı soyutlamalardan oluşan bir kod yığını vardır. <strong>Design patterns</strong>, bu tür soyutlama kulelerini inşa etmede oldukça yardımcı olur.</p><p>Kısa süre içinde, yeni işlevsellik eklemek veya bu karmaşıklığı anlamak giderek zorlaşır. Kod tabanı, şu tür yapılarla dolmaya başlar:</p><ul><li><strong>SimpleBeanFactoryAwareAspectInstanceFactory</strong></li><li><strong>AbstractInterceptorDrivenBeanDefinitionDecorator</strong></li><li><strong>TransactionAwarePersistenceManagerFactoryProxy</strong></li><li><strong>RequestProcessorFactoryFactory</strong></li></ul><p>Geliştiricilerin kendi yarattıkları soyutlama kulesini anlamaya çalışırken, kıymetli zihinsel enerjileri boşa harcanır. Bana sorarsanız, kötü bir yapıya sahip olmak yerine, hiç yapının olmaması çoğu durumda daha iyidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VgcHLbBqrYfnxEEw.png" /></figure><h3>OOP’nin Dört Sütununun Çöküşü</h3><p>Nesne Yönelimli Programlama’nın (OOP) dört temel sütunu şunlardır:</p><ol><li><strong>Abstraction</strong></li><li><strong>Inheritance</strong></li><li><strong>Encapsulation</strong></li><li><strong>Polymorphism</strong></li></ol><p>Şimdi, bunların ne olduklarına ve neden sorun yarattıklarına tek tek bakalım.</p><h4>Inheritance</h4><blockquote><strong><em>“Nesne yönelimli dillerde yeniden kullanılabilirlik eksikliği var, fonksiyonel dillerde değil. Nesne yönelimli dillerin problemi, yanlarında bir sürü örtük çevre taşımaları. Siz sadece bir muz istiyorsunuz, ama elinize bir muzu tutan bir goril ve onunla birlikte tüm orman geçiyor.”</em></strong><em><br> — </em><strong><em>Joe Armstrong</em></strong><em>, Erlang’in yaratıcısı</em></blockquote><p><strong>Inheritance</strong>, gerçek dünyayla hiçbir ilgisi olmayan bir OOP özelliğidir. Aslında, kodun yeniden kullanılabilirliğini sağlamak için <strong>daha düşük bir yöntemdir.</strong> “Gang of Four” bile <strong>inheritance yerine composition’ı tercih etmeyi</strong> açıkça önermiştir. Günümüzde bazı modern programlama dilleri inheritance kullanımından tamamen kaçınır.</p><p>Inheritance ile ilgili başlıca problemler:</p><ol><li>Sınıfınıza ihtiyaç duymadığı bir sürü kodu dahil eder (<strong>banana and the jungle</strong> problemi).</li><li>Sınıfınızın bazı kısımlarının başka bir yerde tanımlanmış olması, özellikle çok seviyeli inheritance’larda kodu anlamayı zorlaştırır.</li><li>Çoğu programlama dilinde <strong>çoklu inheritance</strong> mümkün değildir. Bu, inheritance’ı bir kod paylaşım mekanizması olarak büyük ölçüde işe yaramaz hale getirir.</li></ol><h4>Polymorphism</h4><p>Polymorphism, çalışma zamanında program davranışını değiştirmemizi sağlar, bu oldukça faydalıdır. Ancak, bu bilgisayar programlamada <strong>çok temel bir konsepttir.</strong> OOP’nin neden polymorphism’e bu kadar fazla odaklandığı açık değildir.</p><p>OOP polymorphism iş görür, ancak yine de zihinsel bir akrobasiye neden olur. Kod tabanını önemli ölçüde daha karmaşık hale getirir ve çağrılan somut method’u anlamayı oldukça zorlaştırır.</p><p>Buna karşılık, <strong>fonksiyonel programlama</strong>, polymorphism’i çok daha zarif bir şekilde sağlar — yalnızca istenen çalışma zamanı davranışını tanımlayan bir fonksiyon geçirerek. Bundan daha basit ne olabilir? Birden fazla dosyada (ve interface’lerde) bir sürü aşırı yüklenmiş soyut sanal method tanımlamaya gerek yok.</p><h4>Encapsulation</h4><p>Daha önce tartıştığımız gibi, <strong>encapsulation</strong>, OOP’nin <strong>Truva Atı</strong>dır. Aslında, yüceltilmiş bir <strong>global mutable state</strong>’dir ve güvensiz kodu güvenli gibi gösterir. OOP geliştiricileri, günlük işlerinde bu güvensiz kodlama pratiğine dayanmaktadır.</p><h4>Abstraction</h4><p><strong>Abstraction</strong>, OOP’de karmaşıklığı azaltmayı, gereksiz detayları geliştiriciden gizlemeyi amaçlar. Teorik olarak, geliştiricinin gizli karmaşıklığı düşünmeden kod tabanı hakkında fikir yürütebilmesini sağlamalıdır.</p><p>Ancak, bu temelde çok basit bir konsept için süslü bir terimdir. Prosedürel veya fonksiyonel dillerde, bir dosya yapısını kullanarak uygulama detaylarını basitçe “gizleyebiliriz.” Bu temel eylemi “abstraction” olarak adlandırmaya gerek yoktur.</p><h3>Neden OOP Endüstride Hakim?</h3><p>Cevap basit: <strong>Reptiloid uzaylı ırkı, NSA (ve Ruslar) ile birlikte programcıları ölene kadar işkence etmek için bir komplo kurdu…</strong></p><p>Ama Cidden, Cevap Muhtemelen Java</p><blockquote><strong><em>“Java, MS-DOS’tan bu yana bilişim dünyasında yaşanan en üzücü şeydir.”</em></strong><em><br> — </em><strong><em>Alan Kay</em></strong><em>, Nesne Yönelimli Programlama’nın mucidi</em></blockquote><p>Java, Nesne Yönelimli Programlama’nın yayılmasında ve endüstride hakimiyet kurmasında muhtemelen en büyük rolü oynayan dildir. Ancak, bu süreçte ortaya çıkan karmaşıklıklar ve sınırlamalar, OOP’nin eleştirilen birçok yönünün temel nedenlerinden biridir. Alan Kay’in bu sert yorumu, OOP’nin orijinal fikirlerinin nasıl yanlış anlaşıldığını ve modern OOP dillerinin ne ölçüde hayal kırıklığı yarattığını açıkça göstermektedir.</p><h4>Java Eskiden Basitti</h4><p>1995’te ilk tanıtıldığında, Java, alternatiflerine kıyasla oldukça basit bir programlama diliydi. O dönemde, masaüstü uygulamaları yazmak oldukça zordu. Masaüstü uygulamaları geliştirmek için genellikle <strong>C</strong> ile düşük seviyeli <strong>win32 API’lerini</strong> yazmak gerekiyordu ve geliştiriciler aynı zamanda manuel bellek yönetimiyle uğraşmak zorundaydılar. Diğer bir alternatif ise <strong>Visual Basic</strong> idi, ancak pek çok geliştirici Microsoft ekosistemine bağlı kalmak istemiyordu.</p><p>Java tanıtıldığında, birçok geliştirici için bir <strong>“no-brainer”</strong> (tereddütsüz tercih) oldu, çünkü ücretsizdi ve tüm platformlarda kullanılabiliyordu. Java’yı daha erişilebilir kılan diğer özellikler şunlardı:</p><ul><li>Dahili <strong>garbage collection</strong>,</li><li><strong>Win32 API’lerine</strong> kıyasla daha okunabilir ve kullanıcı dostu API isimleri,</li><li>Doğru yapılandırılmış namespace’ler,</li><li>C’ye benzeyen tanıdık bir söz dizimi.</li></ul><p>GUI programlaması da giderek daha popüler hale geliyordu ve birçok UI bileşeni sınıflara iyi bir şekilde uyuyormuş gibi görünüyordu. Ayrıca, IDE’lerdeki <strong>method tamamlama</strong> (autocompletion) özelliği, OOP API’lerinin kullanımı daha kolay hale getirildiği iddialarını beraberinde getirdi.</p><p>Belki de Java, geliştiricilere OOP’yi <strong>zorunlu</strong> kılmasaydı bu kadar eleştirilmezdi. Java’nın OOP dışında kalan diğer özellikleri oldukça iyiydi. Örneğin:</p><ul><li><strong>Garbage collection</strong> mekanizması,</li><li>Platform bağımsızlık (portability),</li><li>Exception handling (istisna yönetimi) özellikleri,</li></ul><p>1995 yılında diğer ana akım programlama dillerinde olmayan gerçekten etkileyici özelliklerdi.</p><h4>Sonra C# Geldi</h4><p>Başlangıçta Microsoft, Java’ya büyük ölçüde güveniyordu. Ancak işler ters gitmeye başladığında (ve Sun Microsystems ile Java lisanslama konusunda uzun bir hukuki mücadeleden sonra), Microsoft kendi Java versiyonuna yatırım yapmaya karar verdi. İşte bu noktada <strong>C# 1.0</strong> doğdu.</p><p>C#, her zaman <strong>“daha iyi bir Java”</strong> olarak düşünülmüştür. Ancak büyük bir sorun vardı: <strong>Aynı OOP diliydi ve aynı kusurları taşıyordu, sadece biraz geliştirilmiş bir söz dizimi ile gizlenmişti.</strong></p><h4>Microsoft’un Yatırımları</h4><p>Microsoft, .NET ekosistemine büyük yatırımlar yaptı ve bu ekosistem iyi geliştirici araçlarını da içeriyordu. Yıllardır <strong>Visual Studio</strong>, muhtemelen en iyi IDE’lerden biri olarak kabul edildi. Bu durum, özellikle kurumsal dünyada <strong>.NET Framework’ün</strong> yaygın olarak benimsenmesine yol açtı.</p><p>Son zamanlarda Microsoft, tarayıcı ekosistemine de yoğun bir şekilde yatırım yaparak <strong>TypeScript’i</strong> öne çıkardı.</p><ul><li><strong>TypeScript</strong>, saf JavaScript’i derleyebilmesi ve statik tip denetimi gibi özellikler eklemesi nedeniyle harikadır.</li><li>Ancak, <strong>fonksiyonel yapılar</strong> için doğru düzgün bir destek sunmaması dezavantajdır: Dahili değiştirilemez veri yapıları, function composition veya doğru bir pattern matching desteği yoktur.</li></ul><p>TypeScript, OOP’yi öncelikli tutar ve büyük ölçüde tarayıcı için bir <strong>C#</strong> gibidir. Zaten hem C#’ın hem de TypeScript’in tasarımından <strong>Anders Hejlsberg</strong> sorumludur.</p><h4>Fonksiyonel Diller</h4><p>Fonksiyonel diller ise hiçbir zaman Microsoft gibi büyük bir kuruluş tarafından desteklenmedi. <strong>F# bu konuda sayılmaz</strong>, çünkü yapılan yatırım oldukça küçüktü.</p><p>Fonksiyonel dillerin gelişimi çoğunlukla topluluk odaklıdır. Bu durum, OOP ile FP dillerinin popülaritesi arasındaki farkı açıklıyor olabilir. OOP, güçlü kurumsal destekler sayesinde daha fazla yaygınlık kazanmıştır.</p><h4>Devam Etme Zamanı mı?</h4><blockquote><strong><em>“OOP’nin başarısız bir deney olduğunu artık biliyoruz. Artık devam etmenin zamanı geldi. Bir topluluk olarak, bu fikrin bize başarısızlık getirdiğini kabul etmeli ve bundan vazgeçmeliyiz.”</em></strong><em><br> — </em><strong><em>Lawrence Krubner</em></strong></blockquote><p>Neden, temelde programları organize etmek için <strong>optimum olmayan bir yöntem</strong> kullanmaya takılıp kaldık? Bu sadece bir cehalet mi? Bundan şüpheliyim, yazılım mühendisliğiyle uğraşan insanlar aptal değil.</p><p>Belki de, meslektaşlarımızın önünde “design patterns”, “abstraction”, “encapsulation”, “polymorphism” ve “interface segregation” gibi havalı OOP terimlerini kullanarak <strong>“akıllı görünmek”</strong> konusunda daha mı endişeliyiz? Muhtemelen hayır.</p><h4>Alışkanlıkların Gücü</h4><p>Bence asıl mesele şu: On yıllardır kullandığımız bir şeyi kullanmaya devam etmek gerçekten çok kolay. Çoğu insan, aslında hiç <strong>Fonksiyonel Programlama</strong> denememiştir. Deneyenler (benim gibi) ise bir daha asla OOP yazmaya geri dönemez.</p><h4>Daha Hızlı Atlar mı, Yeni Bir Çözüm mü?</h4><p>Henry Ford’un ünlü sözü bu duruma çok uyuyor:</p><blockquote><strong><em>“İnsanlara ne istediklerini sorsaydım, daha hızlı atlar derlerdi.”</em></strong></blockquote><p>Yazılım dünyasında da benzer bir durum var. Çoğu insan muhtemelen “daha iyi bir OOP dili” ister. İnsanlar, yaşadıkları bir sorunu (kod tabanını daha düzenli ve daha az karmaşık hale getirmek) kolayca tanımlayabilirler, ancak en iyi çözümü tanımlamakta zorlanırlar.</p><h4>Alternatifler Neler?</h4><p><strong>Spoiler: Fonksiyonel Programlama.</strong></p><p>Eğer <strong>functors</strong> ve <strong>monads</strong> gibi terimler sizi biraz huzursuz ediyorsa, yalnız değilsiniz! Fonksiyonel Programlama bu kadar korkutucu olmazdı, eğer bu kavramlara daha sezgisel isimler verilmiş olsaydı.</p><ul><li><strong>Functor</strong>? Bu, bir fonksiyonla dönüştürebileceğimiz bir şeydir. Örneğin, list.map.</li><li><strong>Monad</strong>? Sadece birbirine zincirlenebilen hesaplamalardır!</li></ul><h4>Fonksiyonel Programlama Sizi Daha İyi Bir Geliştirici Yapacak</h4><p>Fonksiyonel Programlama’yı denemek, sizi daha iyi bir geliştirici yapar. Artık zamanınızın çoğunu soyutlamalar ve tasarım kalıpları hakkında düşünmek yerine, gerçek dünyadaki sorunları çözen <strong>gerçek kod</strong> yazmaya ayırabilirsiniz.</p><p>Farkında olmayabilirsiniz, ancak siz zaten bir fonksiyonel programcısınız. Günlük işinizde fonksiyonlar kullanıyor musunuz? <strong>Evet?</strong> O zaman zaten bir fonksiyonel programcısınız! Tek yapmanız gereken, bu fonksiyonları en iyi şekilde nasıl kullanacağınızı öğrenmek.</p><h4>Öğrenmesi Kolay Fonksiyonel Diller</h4><p>Fonksiyonel Programlama’ya giriş için öğrenme eğrisi oldukça yumuşak olan iki harika dil:</p><ul><li><strong>Elixir</strong></li><li><strong>Elm</strong></li></ul><p>Bu diller, geliştiricinin asıl önemli olan şeye odaklanmasını sağlar: <strong>Güvenilir yazılım yazmak</strong>. Geleneksel fonksiyonel dillerin getirdiği karmaşıklığı ortadan kaldırır.</p><h4>Diğer Seçenekler</h4><p><strong>Kuruluşunuz zaten C# mı kullanıyor?</strong></p><ul><li>O zaman <strong>F#’ı</strong> deneyin. Harika bir fonksiyonel dildir ve mevcut .NET koduyla mükemmel bir şekilde birlikte çalışır.</li></ul><p><strong>Java mı kullanıyorsunuz?</strong></p><ul><li><strong>Scala</strong> veya <strong>Clojure</strong>, her ikisi de gerçekten iyi seçeneklerdir.</li></ul><p><strong>JavaScript mi kullanıyorsunuz?</strong></p><ul><li>Doğru yönlendirme ve linting ile JavaScript, iyi bir fonksiyonel dil olabilir.</li></ul><p>Fonksiyonel Programlama’ya geçmek, sadece daha az karmaşıklıkla başa çıkmakla kalmaz, aynı zamanda kodunuzu daha güvenilir ve sürdürülebilir hale getirir.</p><h4>OOP Savunucuları</h4><p>OOP savunucularından bir tepki bekliyorum. Bu makalenin yanlışlarla dolu olduğunu söyleyeceklerdir. Bazıları isim takmaya başlayabilir, hatta beni <strong>“gerçek dünyada OOP deneyimi olmayan bir junior geliştirici”</strong> olarak nitelendirebilirler. Belki de varsayımlarımın hatalı, örneklerimin ise anlamsız olduğunu söyleyecekler. <strong>Ne yapalım, herkesin fikrine saygımız var.</strong></p><p>Ancak, OOP’yi savunan argümanlar genellikle oldukça zayıf oluyor. İşin ironik tarafı, bu savunucuların çoğunun muhtemelen gerçek bir fonksiyonel dilde hiç program yazmamış olması. İki şey arasında karşılaştırma yapmak, ancak ikisini de gerçekten denemişseniz faydalı olabilir. Aksi takdirde bu tür karşılaştırmalar pek bir işe yaramaz.</p><h4>The Law of Demeter (Demeter Kanunu)</h4><p>Savunucular, <strong>Demeter Kanunu’nun</strong> OOP kodundaki sorunları çözdüğünü iddia edebilir. Ancak, bu yasa <strong>deterministik olmayan davranışları düzeltmek için pek bir şey yapmaz.</strong> Paylaşılan değiştirilebilir durum, <strong>nasıl erişilip değiştirildiğine bakılmaksızın</strong> paylaşılan değiştirilebilir durum olarak kalır.</p><p>Örneğin:</p><ul><li>a.total() ile</li><li>a.getB().getC().total()</li></ul><p>arasında büyük bir fark yoktur. <strong>Demeter Kanunu</strong>, problemi yalnızca halının altına süpürür.</p><h4>Domain-Driven Design (DDD)</h4><p>Peki ya <strong>Domain-Driven Design (DDD)?</strong><br>Evet, bu yararlı bir tasarım metodolojisidir ve karmaşıklıkla mücadelede biraz yardımcı olabilir. Ancak, bu da paylaşılan değiştirilebilir durumun temel sorununu ele almak için hiçbir şey yapmaz.</p><p>OOP savunucularının genellikle bu gibi yüzeysel çözümleri, OOP’nin derinlemesine sorunlarını maskelemek için kullandığını görüyoruz. Ancak, bu yaklaşımlar OOP’nin özündeki problemleri çözmek yerine yalnızca geçici çözümler sunuyor.</p><h4>Sadece Bir Araç mı?</h4><p>Sıklıkla, <strong>OOP’nin sadece bir araç kutusundaki başka bir araç</strong> olduğunu söyleyenleri duyuyorum. Evet, OOP bir araçtır ama bu, <strong>atlar ve arabaların</strong> her ikisinin de birer ulaşım aracı olması kadar doğrudur… Sonuçta, her ikisi de aynı amaca hizmet ediyor, değil mi?</p><p>O halde neden arabaları kullanıyoruz ki? <strong>Eski güzel atlara binmeye devam edebiliriz!</strong></p><p>Bu argüman, OOP’nin çağın ihtiyaçlarına cevap vermediğini, daha modern ve etkili araçların mevcut olduğunu ancak alışkanlıkların ve yanlış varsayımların bu geçişi engellediğini açıkça ortaya koyuyor.</p><h3>Tarih Tekrar Ediyor</h3><p>Bu durum bana bir şeyi hatırlatıyor. 20. yüzyılın başlarında, otomobiller atların yerini almaya başladı. <strong>1900 yılında New York’ta yollarda sadece birkaç araba vardı</strong> ve insanlar ulaşım için hala atları kullanıyordu. Ancak, <strong>1917 yılına gelindiğinde artık yollarda hiç at kalmamıştı.</strong></p><p>O dönemde dev bir sektör, atlı ulaşım üzerine kurulmuştu. Gübre temizleme gibi işlere odaklanan tamamen bu sektöre yönelik işletmeler mevcuttu.</p><p>Tabii ki insanlar bu değişime direndi. <strong>Otomobilleri “geçici bir moda” olarak nitelendirdiler.</strong> Atlar yüzyıllardır buradaydı, neden onlardan vazgeçilsin ki? Hatta bazıları, hükümetin müdahale etmesini bile talep etti.</p><h4>Bunun Yazılım Endüstrisiyle Bağlantısı Nedir?</h4><p>Günümüzde yazılım endüstrisi <strong>OOP’nin etrafında şekillenmiş durumda.</strong> Milyonlarca insan OOP konusunda eğitim aldı ve milyonlarca şirket, kod tabanında OOP kullanıyor. Tabii ki, onların geçim kaynaklarını tehdit eden her şeyi itibarsızlaştırmaya çalışacaklar. Bu tamamen mantıklı bir tepki.</p><p>20. yüzyılda atlar ve otomobiller arasındaki çatışmaya tanık olmuştuk. <strong>21. yüzyılda ise Nesne Yönelimli Programlama ve Fonksiyonel Programlama arasındaki çatışmayı görüyoruz.</strong> Tarih bir kez daha kendini tekrarlıyor.</p><p>Bu makale <a href="https://jossbuttler837838383736.medium.com/object-oriented-programming-the-trillion-dollar-disaster-3102f4d40a37">https://jossbuttler837838383736.medium.com/object-oriented-programming-the-trillion-dollar-disaster-3102f4d40a37</a><br>makalesinin türkçeye çevirisidir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=087d30c63377" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Strong Consistency, Eventual Consistency, ve Causal Consistency Karşılaştırması]]></title>
            <link>https://medium.com/@dogukanguney/strong-consistency-eventual-consistency-ve-causal-consistency-kar%C5%9F%C4%B1la%C5%9Ft%C4%B1rmas%C4%B1-94c830fc77c2?source=rss-2bb590437730------2</link>
            <guid isPermaLink="false">https://medium.com/p/94c830fc77c2</guid>
            <category><![CDATA[consistency]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Doğukan Güney@HepsiBurada]]></dc:creator>
            <pubDate>Wed, 18 Dec 2024 09:13:50 GMT</pubDate>
            <atom:updated>2024-12-18T09:13:50.976Z</atom:updated>
            <content:encoded><![CDATA[<h3>1. Consistency Modelleri Nedir?</h3><p>Dağıtık sistemlerde, birden fazla replika (çoğaltılmış veri kopyaları) arasında veri tutarlılığını nasıl sağlayacağımız, consistency modeline bağlıdır.</p><h4>1.1. Strong Consistency</h4><p>Strong consistency, tüm replikalardaki verilerin <strong>her zaman tutarlı</strong> olmasını garanti eder. Bir yazma işlemi tamamlandıktan sonra, tüm okuyucular (readers) <strong>en son yazılan veriyi</strong> görür.</p><ul><li><strong>Avantajlar:</strong> Veri her zaman günceldir ve bu, kritik uygulamalar için idealdir (bankacılık, rezervasyon sistemleri).</li><li><strong>Dezavantajlar:</strong> Yüksek gecikme (latency) ve düşük sistem esnekliği.</li></ul><h4>1.2. Eventual Consistency</h4><p>Eventual consistency, sistemin bir süre sonra <strong>tutarlı bir duruma</strong> ulaşacağını garanti eder. Bir replika yazılırken, diğerleri daha eski veri döndürebilir.</p><ul><li><strong>Avantajlar:</strong> Daha hızlı yazma işlemleri ve düşük gecikme.</li><li><strong>Dezavantajlar:</strong> Geçici veri tutarsızlıkları kritik uygulamalarda sorun yaratabilir.</li></ul><h4>1.3. Causal Consistency</h4><p>Causal consistency, işlemler arasındaki <strong>nedensel ilişkileri</strong> takip eder. Bir olay (write) diğer bir olayı tetiklerse, bu ilişkiler tüm replikalarda korunur. Ancak nedensel bağlantı olmayan işlemler farklı düzenlerde gözlemlenebilir.</p><ul><li><strong>Avantajlar:</strong> Daha iyi performans sağlarken bazı tutarlılık garantileri sunar.</li><li><strong>Dezavantajlar:</strong> Karmaşık bir senkronizasyon gerektirir.</li></ul><h3>2. CAP Teoremi Bağlamında Consistency</h3><p>Dağıtık sistemler, <strong>CAP teoremi</strong> gereği üç özellikten (Consistency, Availability, Partition Tolerance) sadece ikisini optimize edebilir.</p><ul><li><strong>Strong Consistency</strong>: Consistency + Partition Tolerance önceliklidir.</li><li><strong>Eventual Consistency</strong>: Availability + Partition Tolerance önceliklidir.</li><li><strong>Causal Consistency</strong>: Consistency’i kısmen sağlarken, Availability’i optimize eder.</li></ul><h3>3. Consistency Modellerine Örnekler (C#)</h3><h4>3.1. Strong Consistency Örneği</h4><p>Bir bankacılık sistemi düşünelim:</p><pre>public class StrongConsistencyExample<br>{<br>    private static readonly object LockObject = new object();<br>    private static int Balance = 100;<br><br>    public static void Withdraw(int amount)<br>    {<br>        lock (LockObject)<br>        {<br>            if (Balance &gt;= amount)<br>            {<br>                Balance -= amount;<br>                Console.WriteLine($&quot;Withdrawal successful. Remaining Balance: {Balance}&quot;);<br>            }<br>            else<br>            {<br>                Console.WriteLine(&quot;Insufficient funds.&quot;);<br>            }<br>        }<br>    }<br><br>    public static void CheckBalance()<br>    {<br>        lock (LockObject)<br>        {<br>            Console.WriteLine($&quot;Current Balance: {Balance}&quot;);<br>        }<br>    }<br>}</pre><p><strong>Açıklama</strong>: lock ile senkronizasyon sağlanarak tüm işlemlerde tutarlılık garantisi sunulur.</p><h4>3.2. Eventual Consistency Örneği</h4><p>Bir sosyal medya platformunun kullanıcı profili güncellemesi:</p><pre>public class EventualConsistencyExample<br>{<br>    private static Dictionary&lt;string, string&gt; ProfileDatabase = new();<br><br>    public static void UpdateProfile(string userId, string newName)<br>    {<br>        // Update is sent to multiple replicas asynchronously<br>        Console.WriteLine($&quot;Updating profile for {userId} to {newName}...&quot;);<br>        Task.Run(() =&gt; SimulateReplicaUpdate(userId, newName));<br>    }<br><br>    private static async Task SimulateReplicaUpdate(string userId, string newName)<br>    {<br>        await Task.Delay(1000); // Simulate network latency<br>        ProfileDatabase[userId] = newName;<br>        Console.WriteLine($&quot;Replica updated for {userId}: {newName}&quot;);<br>    }<br><br>    public static string GetProfile(string userId)<br>    {<br>        return ProfileDatabase.ContainsKey(userId) ? ProfileDatabase[userId] : &quot;Profile not found&quot;;<br>    }<br>}</pre><p><strong>Açıklama</strong>: Replikalar arası senkronizasyon zaman alabilir, bu nedenle bazı kullanıcılar güncellenmemiş veriler görebilir.</p><h4>3.3. Causal Consistency Örneği</h4><p>Bir chat uygulamasındaki mesajların sırası:</p><pre>public class CausalConsistencyExample<br>{<br>    private static List&lt;(string User, string Message)&gt; ChatHistory = new();<br><br>    public static void SendMessage(string user, string message)<br>    {<br>        ChatHistory.Add((user, message));<br>        Console.WriteLine($&quot;{user}: {message}&quot;);<br>    }<br><br>    public static void PrintChatHistory()<br>    {<br>        foreach (var (user, message) in ChatHistory)<br>        {<br>            Console.WriteLine($&quot;{user}: {message}&quot;);<br>        }<br>    }<br>}</pre><p><strong>Açıklama</strong>: Mesajlar kullanıcılar arasındaki nedensel bağlantıya göre sıralanabilir.</p><h3>Hangi Consistency Modelini Seçmeliyim?</h3><ul><li><strong>Strong Consistency</strong>: Kritik verilerin (para transferleri, rezervasyon sistemleri) doğruluğu garanti edilmeli.</li><li><strong>Eventual Consistency</strong>: Performansın kritik olduğu, ancak geçici tutarsızlığı edilebilir olan uygulamalar için uygundur (sosyal medya, IoT cihazları).</li><li><strong>Causal Consistency</strong>: Nedensel ilişkilerin önemli olduğu durumlar (chat uygulamaları, proje işbirlikçi yazılımlar).</li></ul><h3>5. Performans ve Tutarlılık Dengesi</h3><p>Consistency modelini seçerken şu faktörleri göz önünde bulundurmalısınız:</p><h4>5.1. Gecikme (İletim Süresi)</h4><ul><li>Strong consistency genellikle en yüksek gecikmeyi yaratır, çünkü her yazma işlemi replikalara hemen dağıtılmalıdır.</li><li>Eventual consistency, yazma işlemlerini asenkron olarak dağıttığından daha hızlıdır.</li></ul><h4>5.2. Veri Okuma Tutarlılığı</h4><ul><li>Strong consistency, daima en güncel veriyi sağlar.</li><li>Eventual consistency, okuma sırasında bazen eski veriyi döndürebilir.</li><li>Causal consistency, nedensel ilişkiye dayalı güncel veriler sunar.</li></ul><h4>5.3. Çoklu Replika Senaryoları</h4><ul><li>Global olarak dağıtılmış sistemlerde eventual consistency ve causal consistency, latency’yi azaltarak daha iyi bir son kullanıcı deneyimi sunar.</li></ul><h3>6. Sonuç</h3><p>Her consistency modelinin belirli avantaj ve dezavantajları vardır. Sisteminizin gereksinimlerine göre doğru model seçimi, performans ve veri doğruluğu arasındaki dengeyi sağlamanızda kritik rol oynar.</p><ul><li><strong>Strong Consistency:</strong> Kritik uygulamalarda veri tutarlılığı garantisi.</li><li><strong>Eventual Consistency:</strong> Performans odaklı, hızlı ve esnek uygulamalar.</li><li><strong>Causal Consistency:</strong> Nedensel ilişkileri koruyan, düşük gecikmeli sistemler.</li></ul><p>Dağıtık sistem tasarımlarında bu modellerden hangisinin uygulanacağına karar vermek, yazılım mimarisinin başarısını belirleyen en önemli adımlardan biridir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94c830fc77c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aggressive Caching]]></title>
            <link>https://medium.com/@dogukanguney/aggressive-caching-8a9269bdb18f?source=rss-2bb590437730------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a9269bdb18f</guid>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[cache-invalidation]]></category>
            <category><![CDATA[cache]]></category>
            <dc:creator><![CDATA[Doğukan Güney@HepsiBurada]]></dc:creator>
            <pubDate>Wed, 11 Dec 2024 13:43:37 GMT</pubDate>
            <atom:updated>2024-12-11T13:43:37.931Z</atom:updated>
            <content:encoded><![CDATA[<p>Web uygulamalarında performans optimizasyonu için cache (önbellek) kullanımı oldukça yaygındır. Ancak, özellikle sık erişilen veriler söz konusu olduğunda, “aggressive caching” stratejileri ek performans artışı sağlayabilir. Bu makalede, .NET ile aggressive cache uygulama yöntemlerini ve örnekleri inceleyeceğiz.</p><h3>Aggressive Cache Nedir?</h3><p>Aggressive cache, sık kullanılan verilerin mümkün olduğunca uzun süre bellekte tutulmasını sağlayarak, veri erişim süresini minimize eden bir stratejidir. Bu yaklaşım genellikle “read-heavy” (okuma ağırlıklı) uygulamalarda tercih edilir. Aggressive cache stratejisi aşağıdaki durumlarda idealdir:</p><ol><li>Verinin güncelliği, performanstan daha az önem taşıyorsa.</li><li>Verilerin değişim sıklığı çok düşükse.</li><li>Okuma operasyonları yazma operasyonlarından çok daha fazlaysa.</li></ol><h3>.NET ile Aggressive Cache Kullanımı</h3><h4>1. MemoryCache Kullanımı</h4><p>.NET Core ve .NET Framework, bellek tabanlı bir önbellek olan MemoryCache sınıfını kullanarak hızlı ve kolay bir şekilde aggressive cache stratejileri uygulanmasına olanak tanır.</p><p><strong>Örnek 1: MemoryCache ile Sabit Verilerin Önbelleğe Alınması</strong></p><pre>using System;<br>using System.Runtime.Caching;<br><br>public class AggressiveCacheExample<br>{<br>    private static readonly MemoryCache Cache = MemoryCache.Default;<br><br>    public static string GetCachedData(string key)<br>    {<br>        if (Cache.Contains(key))<br>        {<br>            return (string)Cache.Get(key);<br>        }<br><br>        // Simulated data retrieval<br>        var data = &quot;Expensive to fetch data&quot;;<br><br>        Cache.Set(key, data, new CacheItemPolicy<br>        {<br>            AbsoluteExpiration = DateTimeOffset.Now.AddHours(1)<br>        });<br><br>        return data;<br>    }<br>}<br><br>// Kullanım<br>var cachedData = AggressiveCacheExample.GetCachedData(&quot;exampleKey&quot;);<br>Console.WriteLine(cachedData);</pre><p>Yukarıdaki kod, sabit bir süre boyunca önbelleğe alınan veriyi getirir. Veriye erişim çok hızlıdır ve bu yaklaşım CPU veya IO yükünü azaltır.</p><h4>2. Distributed Cache Kullanımı</h4><p>Eğer uygulamanız birden fazla sunucuda çalışıyorsa, <strong>distributed cache</strong> çözümleri (örneğin Redis) tercih edilebilir. Distributed cache ile aggressive cache stratejileri uygularsanız, tüm sunucular aynı önbelleğe erişebilir.</p><p><strong>Örnek 2: Redis Cache ile Kullanım</strong></p><pre>using Microsoft.Extensions.Caching.Distributed;<br>using Microsoft.Extensions.DependencyInjection;<br>using System;<br>using System.Text;<br><br>public class AggressiveRedisCacheExample<br>{<br>    private readonly IDistributedCache _distributedCache;<br><br>    public AggressiveRedisCacheExample(IDistributedCache distributedCache)<br>    {<br>        _distributedCache = distributedCache;<br>    }<br><br>    public string GetCachedData(string key)<br>    {<br>        var cachedData = _distributedCache.GetString(key);<br><br>        if (!string.IsNullOrEmpty(cachedData))<br>        {<br>            return cachedData;<br>        }<br><br>        // Simulated data retrieval<br>        var data = &quot;Expensive to fetch data&quot;;<br><br>        _distributedCache.SetString(key, data, new DistributedCacheEntryOptions<br>        {<br>            AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)<br>        });<br><br>        return data;<br>    }<br>}<br><br>// Startup.cs<br>services.AddStackExchangeRedisCache(options =&gt;<br>{<br>    options.Configuration = &quot;localhost:6379&quot;;<br>    options.InstanceName = &quot;SampleInstance&quot;;<br>});<br><br>// Kullanım<br>var cacheExample = new AggressiveRedisCacheExample(distributedCache);<br>var data = cacheExample.GetCachedData(&quot;exampleKey&quot;);<br>Console.WriteLine(data);</pre><p>Redis gibi bir çözüm kullandığınızda, aggressive cache ile daha geniş ölçekli sistemler oluşturabilirsiniz.</p><h4>3. Lazy Loading ile Cache</h4><p>Verilerin önbelleğe alınmasını geciktirerek sadece ihtiyaç duyulan anda yüklenmesini sağlayabilirsiniz. Lazy loading, aggressive cache stratejileriyle birleştiğinde gereksiz önbellek kullanımı engellenebilir.</p><p><strong>Örnek 3: Lazy Loading ile MemoryCache Kullanımı</strong></p><pre>using System;<br>using System.Runtime.Caching;<br><br>public class LazyAggressiveCacheExample<br>{<br>    private static readonly MemoryCache Cache = MemoryCache.Default;<br><br>    public static string GetCachedData(string key)<br>    {<br>        return (string)Cache.AddOrGetExisting(key, new Lazy&lt;string&gt;(() =&gt;<br>        {<br>            Console.WriteLine(&quot;Fetching data...&quot;);<br>            return &quot;Expensive to fetch data&quot;;<br>        }),<br>        new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.Now.AddHours(1) })?.Value;<br>    }<br>}<br><br>// Kullanım<br>var lazyData = LazyAggressiveCacheExample.GetCachedData(&quot;lazyKey&quot;);<br>Console.WriteLine(lazyData);</pre><p>Bu yaklaşımda veriler yalnızca ihtiyaç duyulduğunda önbelleğe alınır ve performans optimizasyonu artırılır.</p><h3>Aggressive Cache İçin En İyi Uygulamalar</h3><ol><li><strong>TTL (Time to Live)</strong>: Önbelleğe alınan veriler için bir zaman aşımı belirleyin.</li><li><strong>Veri Boyutu Sınırlamaları</strong>: Çok büyük verilerin önbelleğe alınmasından kaçının.</li><li><strong>Cache Invalidation</strong>: Veri değiştiğinde önbelleğin güncellenmesini sağlayan mekanizmalar oluşturun.</li><li><strong>Monitor Cache Hits/Misses</strong>: Önbellek kullanımınızı izleyerek optimizasyon yapın.</li></ol><h3>Sonuç</h3><p>Aggressive caching, doğru senaryolarda uygulandığında uygulamanızın performansını önemli ölçüde artırabilir. MemoryCache ve Redis gibi araçları kullanarak .NET uygulamalarınızda bu stratejiyi kolayca uygulayabilirsiniz. Ancak, önbelleğe alınan verilerin güncelliği ve geçerliliği gibi riskleri göz önünde bulundurarak uygun senaryolarda kullanmaya özen gösterin.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a9269bdb18f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>