<?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 Hande Ebrar Gunesdogdu on Medium]]></title>
        <description><![CDATA[Stories by Hande Ebrar Gunesdogdu on Medium]]></description>
        <link>https://medium.com/@handeebrar?source=rss-604ec5d274c2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9JKi--JAmiJv-tmMpBuOzQ@2x.jpeg</url>
            <title>Stories by Hande Ebrar Gunesdogdu on Medium</title>
            <link>https://medium.com/@handeebrar?source=rss-604ec5d274c2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:19:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@handeebrar/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[Veritabanı Değişikliklerini Versiyonlamak: Liquibase Nedir?]]></title>
            <link>https://handeebrar.medium.com/veritaban%C4%B1-de%C4%9Fi%C5%9Fikliklerini-versiyonlamak-liquibase-nedir-2b19ebc68149?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b19ebc68149</guid>
            <category><![CDATA[version-control]]></category>
            <category><![CDATA[database-migration]]></category>
            <category><![CDATA[liquibase]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Tue, 01 Jul 2025 12:02:05 GMT</pubDate>
            <atom:updated>2025-07-01T12:02:30.824Z</atom:updated>
            <content:encoded><![CDATA[<p>Veritabanı geliştirme süreçlerinde karşılaşılan temel zorluklardan biri, yapılan şema değişikliklerinin farklı ortamlara tutarlı ve izlenebilir şekilde aktarılmasıdır. Özellikle ekip çalışmasının yoğun olduğu projelerde, “Hangi tablo eklendi?”, “Yeni indeks ne zaman oluşturuldu?”, “İlgili migration QA ortamına uygulandı mı?” gibi sorulara net yanıtlar bulmak çoğu zaman zorlaşmaktadır. Bu tip bilgiler genellikle dağınık şekilde paylaşılır, dokümante edilmez ve iletişim kanallarında (örneğin Slack) kaybolabilir. Bu durum hem operasyonel hatalara yol açmakta hem de sürüm geçişlerinde belirsizlik yaratmaktadır.</p><p>Bu tür sorunlara çözüm olarak geliştirilen araçlardan biri de Liquibase’tir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XBhxsjeYhXs5EXVQXPikmA.png" /></figure><h3>🍃 Liquibase Nedir?</h3><p>Liquibase, veritabanı şema değişikliklerinin versiyonlanmasını, izlenmesini ve gerekirse geri alınmasını sağlayan açık kaynaklı bir veritabanı migration aracıdır (kaynak koddaki Git kullanımına benzetebiliriz).</p><p>Temel amacı, uygulama geliştirme süreçlerinde veritabanı tutarlılığını sağlamak ve manuel müdahalelere olan ihtiyacı azaltmaktır.</p><p>Liquibase ile yapılan değişiklikler changelog adı verilen dosyalarda tanımlanır. Bu dosyalar farklı formatlarda yazılabilir:</p><ul><li>XML</li><li>YAML</li><li>JSON</li><li>SQL</li></ul><p>Okunabilirlik ve sade yapı açısından YAML formatı, birçok kullanıcı tarafından tercih edilmektedir.</p><h3>✅ Neden Kullanılır?</h3><ul><li><strong>Takım çalışması</strong>: Herkesin aynı sırayla migration yapmasını sağlar.</li><li><strong>Otomasyon</strong>: CI/CD ile birlikte kullanılabilir.</li><li><strong>Versiyon kontrolü</strong>: Değişiklikler Git’te tutulabilir.</li><li><strong>Rollback desteği</strong>: Hatalı değişiklik geri alınabilir.</li><li><strong>Loglama ve audit</strong>: Kim neyi ne zaman değiştirmiş görülebilir.</li></ul><h3>🔧 Liquibase Nasıl Çalışır?</h3><p>Liquibase, veritabanında iki özel tablo oluşturarak çalışır:</p><ul><li>DATABASECHANGELOG</li><li>DATABASECHANGELOGLOCK</li></ul><p>Bu tablolar aracılığıyla uygulanan tüm changeSet kayıt altına alınır.</p><ol><li>Liquibase, changelog.xml dosyasını okur.</li><li>Daha önce çalıştırılmamış changeset’leri veritabanına uygular.</li><li>Uyguladığı changeset’leri veritabanında DATABASECHANGELOG adlı tabloya kaydeder.</li><li>Aynı changeset bir daha çalıştırılmaz (idempotent yapı).</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*w3qYpr-vhruXcrt7.png" /></figure><h3>🧪 Örnek: Tablo Oluşturma (YAML)</h3><p>Aşağıda basit bir tablo oluşturma işlemini tanımlayan bir YAML örneği yer almaktadır:</p><pre>databaseChangeLog:<br>  - changeSet:<br>      id: 1<br>      author: user<br>      changes:<br>        - createTable:<br>            tableName: person<br>            columns:<br>              - column:<br>                  name: id<br>                  type: int<br>                  autoIncrement: true<br>                  constraints:<br>                    primaryKey: true<br>              - column:<br>                  name: name<br>                  type: varchar(255)</pre><p>Bu dosya changelog.yaml adıyla kaydedildikten sonra aşağıdaki komut çalıştırılarak veritabanına uygulanabilir:</p><pre>liquibase --changeLogFile=changelog.yaml update</pre><p>Komut çalıştırıldığında ilgili tablo oluşturulur ve DATABASECHANGELOG tablosuna ilgili kayıt eklenir.</p><h3>🌀 CI/CD Süreçlerinde Liquibase Kullanımı</h3><p>Liquibase, sadece local ortamlarda değil, CI/CD süreçlerinde de kolayca kullanılabilir.</p><p>Örneğin GitLab CI ortamında Liquibase şu şekilde tanımlanabilir:</p><pre>liquibase_update:<br>  image: liquibase/liquibase<br>  script:<br>    - liquibase --url=$DB_URL --changeLogFile=changelog.yaml update</pre><p>Bu yapı sayesinde her bir pipeline çalıştırıldığında ilgili veritabanı değişiklikleri otomatik olarak uygulanır.</p><h3>🔄 Rollback Mekanizması</h3><p>Liquibase’in dikkat çeken özelliklerinden biri de geri alma (rollback) desteğidir. Her changeSet için opsiyonel olarak rollback tanımı yapılabilir. Bu sayede, istenmeyen bir değişiklik yapıldığında, tanımlanan rollback adımları sayesinde ilgili işlem geri alınabilir.</p><p>Örneğin bir tablo oluşturulduysa, rollback olarak aynı tablonun silinmesi tanımlanabilir:</p><pre>- changeSet:<br>    id: 2<br>    author: user<br>    changes:<br>      - createTable:<br>          tableName: example<br>          columns:<br>            - column:<br>                name: id<br>                type: int<br>    rollback:<br>      - dropTable:<br>          tableName: example</pre><h3>🗂 Changelog Dosyası Yönetimi</h3><p>Geniş ölçekli projelerde tüm migration adımlarını tek bir dosyada toplamak yerine, dosyaları bölmek yönetimi kolaylaştırır. Liquibase, include ve includeAll ifadeleriyle bu ihtiyaca çözüm sunar.</p><pre>databaseChangeLog:<br>  - include:<br>      file: changesets/init/create-person-table.yaml<br>  - include:<br>      file: changesets/init/add-index.yaml</pre><p>Bu yapı sayesinde her tabloya veya özelliğe özel dosyalar oluşturularak modüler bir yapı elde edilebilir.</p><h3>🧩 Dikkat Edilmesi Gerekenler</h3><ul><li>Her changeSet için benzersiz bir id ve author tanımı yapılmalıdır.</li><li>Büyük projelerde dosya yapısının düzenli tutulması önemlidir.</li><li>Ortak çalışılan ekiplerde belirli bir changelog format standardı oluşturulmalıdır.</li><li>Değişiklikler production ortamına uygulanmadan önce geliştirme ortamında test edilmelidir.</li></ul><h3>🎯 Sonuç</h3><p>Liquibase, veritabanı değişikliklerinin düzenli, izlenebilir ve geri alınabilir biçimde yönetilmesini sağlayarak yazılım geliştirme süreçlerinde önemli bir kolaylık sunar. Özellikle çoklu ortamda çalışan ve CI/CD süreçlerine sahip projelerde veritabanı tutarlılığı için etkili bir çözümdür.</p><h3>📚 Kaynaklar</h3><ul><li><a href="https://docs.liquibase.com/home.html">Liquibase Resmi Dokümantasyonu</a></li><li><a href="https://github.com/liquibase/liquibase">Liquibase GitHub Repository</a></li><li><a href="https://docs.liquibase.com/change-types/home.html">Liquibase Change Types — YAML Formatı Örnekleri</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b19ebc68149" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrent Programming with Go — 3]]></title>
            <link>https://handeebrar.medium.com/concurrent-programming-with-go-3-2ced562c2b7?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ced562c2b7</guid>
            <category><![CDATA[concurrent-programming]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Thu, 29 Dec 2022 19:51:16 GMT</pubDate>
            <atom:updated>2022-12-29T20:20:31.966Z</atom:updated>
            <content:encoded><![CDATA[<h3>Concurrent Programming with Go — 3</h3><p><a href="https://medium.com/@handeebrar/concurrent-programming-with-go-2-fa8e4f233aca">Bir önceki yazı</a>da, task’ların senkronizasyonunu sağlayabilmek için <em>sync package</em>, shared memory konusu için <em>mutex</em> kavramlarına değindik. Serinin bu yazısında ise, birden fazla Goroutine arasındaki çalışmayı koordine etmeyi sağlayan <em>channel’</em>lardan bahsedeceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sKoCvj341WWkJKNWwaWDfg.jpeg" /></figure><p><strong><em>Channels</em></strong></p><p>Channel’ların çalışma mantığını Rob Pike’ın şu cümlesiyle özetleyebiliriz:</p><blockquote>Don’t communicate by sharing memory; share memory by communicating.</blockquote><p>Uygulamalarımız genişledikçe, birden fazla concurrent task arasında paylaşıldığında belleği yönetmek çok zor olabilir. Shared memory’deki read/write işlemleri için mutex kullanabiliriz fakat ve uygulamanın tamamına yayılmış olan birden çok Goroutine arasında paylaşıldığı için zamanla yönetimi zorlaşabilir. Bunun yerine channel’ları kullanabiliriz.</p><p>Mutex, belleğin belirli bir kısmını korur ve sadece bir işlem belleği manipüle edebilir. Channel ise belleğin bir kopyalarını oluşturur ve uygulamaya bunu iletir. Channel’ın bir tarafında mesajı gönderecek olan bir gönderen Goroutine(sender), diğer tarafta da mesajı alan başka bir Goroutine(receiver) bulunur. Burada alınan mesaj, orijinal mesajın kendisi değil, kopyası olacaktır. Dolayısıyla Goroutine’ın lock, unlock gibi yapıları bilmesine ve kontrol etmesine gerek kalmaz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oz5lnn3q9sFzUckh2NWe8A.png" /></figure><p>Channel oluşturmak için Go’daki built-in function’lardan <strong>make()</strong> kullanılır. Bu fonksiyona, channel ile gönderilecek ve alınacak mesajın tipinin parametre olarak belirtilmesi gerekir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fbbd03bb0b4b09d454df709f40e76b0a/href">https://medium.com/media/fbbd03bb0b4b09d454df709f40e76b0a/href</a></iframe><p>Channel’lar sayesinde Goroutine’ler birbirleriyle ilgili bir şey bilmek durumunda kalmaz. Aşağıdaki kod parçasında 13. satırda bulunan goroutine sadece channel içerisine 42 numarasının gönderildiğini bilir. Receiver tarafta bulunan, 8. satırdaki goroutine channel’dan bir tamsayı alacağını bilir, ancak bunun nereden geldiğiyle ilgilenmez. Yani bu iki goroutine birbirinden tamamen ayrılmıştır. Sahip oldukları tek bağımlılık, goroutine’ler arasındaki koordinasyonu sağlayan channel’dır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7cc3e741ce009725d6e9c27670b7030a/href">https://medium.com/media/7cc3e741ce009725d6e9c27670b7030a/href</a></iframe><p><strong><em>Channel Types</em></strong></p><p>Channel default olarak, mesajı gönderen ve gönderilen mesajı alan bidirectional channel type’ında oluşturulurlar. Ancak ihtiyaca göre farklı channel type’lar da seçilebilinir. Send-only sadece mesaj gönderen, receive-only sadece gönderilen mesajı alan channel type’lardır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b593a65eab37d4a62ef9137037fc4f06/href">https://medium.com/media/b593a65eab37d4a62ef9137037fc4f06/href</a></iframe><p><strong><em>Closing Channels</em></strong></p><p>Uygulamamızda, bir süre sonra channel içerisinden göndereceğimiz mesaj kalmayabilir. Bu durumda receiver’a daha fazla mesaj gelmeyeceğini bildirmek için bu channel’ı kapatmamız gerekir. Burada dikkat etmemiz gereken bir konu ise kapatılan channel’ların tekrar kullanımında problem yaşanacağıdır.</p><p>Bir channel’ı kapattıktan sonra tekrar mesaj göndermeyi denersek uygulama panic fırlatır.😱 Kapalı olan bir channel’dan mesaj almayı denersek default değer döner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2uKVbjhmQFbwI05WOVZcUg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*XG0trLRzBesyiuMbiUvW7w.png" /></figure><p>Bu gibi durumlarda kullanılan channel’ın kapalı olup olmadığını anlamak için uygulamamızda control-flow’lardan faydalanabiliriz. Channel’ın açık olup olmadığını ok parametresiyle kontrol edip, sadece açık olduğu durumlarda mesaj send/receive yapılır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bdd2419f5569df3916fd733a7ea6c4a7/href">https://medium.com/media/bdd2419f5569df3916fd733a7ea6c4a7/href</a></iframe><p><strong><em>Select Statements</em></strong></p><p>Go’da sadece channel’lara özel bir control-flow olarak bulunun select statements, switch-case yapısına benzer. Switch-case’deki gibi bir koşula karşı doğruluğu kontrol etmek yerine, bir channel’dan mesaj göndermeyi veya almayı deneriz.</p><p>İlk case, ch1&#39;den → i değişkenine mesaj almayı deniyor. Diğer case ise ch’ye “hello” metnini göndermeyi deniyor. Uygulamada o anda alınmayı bekleyen bir mesaj varsa ilk case’e, gönderilmeyi bekleyen mesaj varsa ikinci case’e girecek. İki durum da aynı anda gerçekleşirse rastgele olarak case seçilir ve çalışır. Switch-case’deki gibi önceden belirlenmiş bir sıra yoktur.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bc74bf25b0b8afcba8ec7d0c6990a2c8/href">https://medium.com/media/bc74bf25b0b8afcba8ec7d0c6990a2c8/href</a></iframe><p>Select deyimi bir case‘i gerçekleştirirken diğer tüm case’lerin çalışmasını bloklar. ch1&#39;den mesaj alana kadar ya da ch2&#39;den mesaj gönderene kadar goroutine burada duracaktır. Buna <em>blocking select statement </em>denir. default keyword kullanarak bu bloklama kaldırılabilinir (<em>non-blocking select</em>).</p><p>Bu seride(<a href="https://handeebrar.medium.com/concurrent-programming-with-go-1-23ba18e8ff65">1</a> , <a href="https://handeebrar.medium.com/concurrent-programming-with-go-2-fa8e4f233aca">2</a>) Go’da concurrent programlamaya ayrıntılarıyla değinmeye çalıştım. Okuyan ve destek olan herkese teşekkür ederim. Faydalı olması dileğiyle! 🌟</p><p><strong><em>References and Links</em></strong></p><p>⭐ Concurrency in Go, <a href="https://learning.oreilly.com/search/?query=author%3A%22Katherine%20Cox-Buday%22&amp;sort=relevance&amp;highlight=true">Katherine Cox-Buday</a></p><p>⭐ <a href="https://go.dev/tour/concurrency/1">A Tour of Go, Concurrency</a></p><p>⭐ <a href="https://www.educative.io/answers/what-are-channels-in-golang">What are channels in Golang?, Educative Answers Team</a></p><p>⭐ Concurrent Programming with Go, By <a href="https://app.pluralsight.com/profile/author/mike-vansickle">Mike Van Sickle</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ced562c2b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrent Programming with Go — 2]]></title>
            <link>https://handeebrar.medium.com/concurrent-programming-with-go-2-fa8e4f233aca?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa8e4f233aca</guid>
            <category><![CDATA[concurr]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Tue, 18 Oct 2022 19:15:08 GMT</pubDate>
            <atom:updated>2022-10-18T19:15:08.945Z</atom:updated>
            <content:encoded><![CDATA[<h3>Concurrent Programming with Go — 2</h3><p>Bu yazıda <a href="https://medium.com/@handeebrar/concurrent-programming-with-go-1-23ba18e8ff65">serinin ilk yazısı</a>nda bahsettiğim concurrency ve goroutine’in devamı olan sync package’tan bahsedeceğim.</p><p>Keyifli okumalar! ✌️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a9ct99VWo-oLUnJrhb2VxQ.png" /></figure><p>Goroutine’lerin birbirleriyle koordine olarak çalışabilmelerini sağlayacak built-in bir mekanizmaları yoktur. Aynı adres alanında çalışabilirler, bu nedenle shared-memory’e erişimin senkronize edilmesi gerekir. Buna bir çözüm olarak: <a href="https://pkg.go.dev/sync">sync package</a></p><h4>sync package</h4><p>Mutual exclusion lock gibi temel senkronizasyon öğelerini içererek Goroutine’lerin birlikte çok daha sorunsuz çalışmasına imkan sağlar.</p><p>Concurrency’nin beraberinde getirdiği bazı problem vardır:</p><ol><li>Task’ların senkronizasyonunu sağlayabilmek</li><li>Shared-memory’e aynı anda birçok yerden erişilmesi</li></ol><p>sync package’da bu problemlere çözüm olacak imkanlar mevcut:</p><ol><li><strong><em>waitGroup, </em></strong>bir<strong><em> </em></strong>Goroutine koleksiyonunun işlemlerinin bitmesini bekler.</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1be305cd787fdce76791774f4164e515/href">https://medium.com/media/1be305cd787fdce76791774f4164e515/href</a></iframe><p>main goroutine, <em>Add()</em> fonksiyonuyla beklenecek goroutine sayısını bildirir. Ardından, goroutine’lerin her biri çalışır ve bittiğinde <em>Done()</em> fonksiyonunu çağırır. Aynı zamanda Wait(), tüm goroutine’ler bitene kadar kodun belirli kısmını bloklamak için kullanılabilir.</p><p>waitGroup’u fonksiyona parametre olarak geçmek istersek mutlaka bir pointer kullanmalıyız. Çünkü, program mantığını bozacak olan counter’ı etkileyebilir.</p><p>2. <strong><em>mutex,</em></strong> A <strong>Mut</strong>ual <strong>Ex</strong>clusion Lock</p><p>mutex’in ne işe yaradığını bir örnekle açıklamaya çalışalım: Örneğin belirli aralıklarla güncellenen ve çok sayıda get yapılan datalarınız var. Her seferinde veri tabanından okuma işlemi yapmak yerine bu dataları cache’e yazdınız. Bu cache’e her 30 dakikada 1 write işlemi yapılıyor ve sürekli read işlemi ile farklı servislerden datalar get ediliyor. Peki write işlemi <strong>tamamlanmadan</strong> read işlemi de aynı ana denk gelirse ne olacak?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*OvdW78bEVp805MOeuFXw9g.png" /><figcaption>go run — — race .</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*29fp40s-oiKoky-XavmArQ.png" /></figure><p>mutex, race condition oluşmasını önlemek için, bir process işlenirken diğer process’lerin critical-section dediğimiz paylaşılan kaynaklar içeren kod parçasına erişimini engelleyen mutual exclusion lock yapısıdır.</p><p>Temel olarak: lock the mutex → access the memory → unlock the mutex şeklinde çalışır. Aşağıda Lock() ile ortak belleğe erişen kod parçasına başka bir process’in girmesini engelledik. İşlem bittikten sonra Unlock() ile buranın tekrar erişilebilir olmasını sağladık.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6e39f8e7b7b0f5ebc314154f7b8c60dd/href">https://medium.com/media/6e39f8e7b7b0f5ebc314154f7b8c60dd/href</a></iframe><p>Gerçek uygulamalarda read ve write işlem sayıları eşit olmayabilir. Genellikle read işlem sayısı, write işlem sayısından daha fazladır. Bu gibi durumlarda mutex’i daha verimli kullanabilmek için:</p><p><strong><em>RWMutex</em></strong> (Read/Write Mutex): Read process’leri birbirlerini beklemek zorunda değil, sadece lock’lanmış write process’lerinin tamamlanmasını beklerler.</p><blockquote>RLock() / RUnlock() → read process’leri için</blockquote><blockquote>Lock() / Unlock() → write process’leri için</blockquote><p>Bu yazıda goroutine’lerin birbiriyle senkronizasyonunu sağlamak için temel ilkeler sunan sync package’ı inceledik. Buradaki ilkelerin uygulamalarımızdaki goroutine’lerin yönetimi konusunda zayıf kalabileceğini belirtmek isterim. Serinin bir sonraki yazısında sync package’a alternatif olarak neler kullanabiliriz buna deyineceğim. Tekrar buluşmak dileğiyle! 🌟</p><p><strong><em>References and Links</em></strong></p><p>⭐ Concurrency in Go, <a href="https://learning.oreilly.com/search/?query=author%3A%22Katherine%20Cox-Buday%22&amp;sort=relevance&amp;highlight=true">Katherine Cox-Buday</a></p><p>⭐ <a href="https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html">Concurrent and Parallel Programming, Joe Armstrong</a></p><p>⭐ <a href="https://www.golangprograms.com/go-language/concurrency.html">Golang Concurrency</a></p><p>⭐ <a href="https://www.golang-book.com/books/intro/10">Concurrency</a></p><p>⭐ Concurrent Programming with Go, By <a href="https://app.pluralsight.com/profile/author/mike-vansickle">Mike Van Sickle</a></p><p>⭐ Go Course: Sync Package, <a href="https://dev.to/karanpratapsingh">Karan Pratap Singh</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa8e4f233aca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrent Programming with Go — 1]]></title>
            <link>https://handeebrar.medium.com/concurrent-programming-with-go-1-23ba18e8ff65?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/23ba18e8ff65</guid>
            <category><![CDATA[concurrent-programming]]></category>
            <category><![CDATA[parallelism]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Mon, 05 Sep 2022 20:21:30 GMT</pubDate>
            <atom:updated>2022-09-05T20:21:30.356Z</atom:updated>
            <content:encoded><![CDATA[<h3>Concurrent Programming with Go — 1</h3><p>Bu seride sizlerle Golang özelinde concurrent programming konusunda yaptığım araştırmalarımda elde ettiğim notları paylaşıyor olacağım.</p><p>Keyifli okumalar! ✌️</p><p><strong>Concurrency</strong>, tek işlem birimi kullanılarak sistemin yanıt süresini azaltmak için kullanılan bir yaklaşımdır. CPU aynı anda yalnızca bir görev üzerinde çalışabilir. Eğer birden fazla görev verilirse (örneğin kod yazarken müzik dinlemek) bu görevler arasında geçiş yapar. Bu geçiş o kadar hızlıdır ki kullanıcı tarafından fark edilmez. Böylece tek seferde tamamlanan iş miktarını artırır.</p><p>Concurrency ve parallelism birbirlerinden farklı kavramlardır. Çoğu işlemcinin birden fazla çekirdeği vardır. Bazı durumlarda da bir makinede birden fazla işlemci olabilir. Birden fazla işlemcinin aynı anda birçok işlemi gerçekleştirmesine <strong>parallelism</strong> denir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*Z08NN_yk-sG9LfKKK3jmMw.jpeg" /></figure><p>Birden fazla yapılacak işin olması <em>concurrency</em>, bu işlerin aynı anda yapılabilir olması <em>parallelism</em> olarak özetleyebiliriz.</p><p>Golang’de concurrency, fonksiyonların birbirinden bağımsız olarak çalışma yeteneğidir. Diğer programlama dilleri, thread kullanarak concurrency sağlar. Golang’in built-in concurrency yapıları vardır: goroutine ve channels.</p><p>Goroutine, kodun geri kalanıyla aynı anda çalışabilen bir fonksiyondur ve thread’ler ile karşılaştırıldığında çok daha az maliyetlidir. Concurrent programming için Go’da yaygın olarak kullanılırlar ve Go runtime tarafından yönetilirler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hqpEdGBYh2O_MhUUIUp8cw.png" /></figure><p>Bu yazıda concurrency’i daha anlaşılır kılmak adına parallelism ile arasındaki farklara değindik ve Go’da concurrent programming’e ufak bir giriş yaptık. Serinin bir sonraki yazısında tekrar buluşmak dileğiyle! 🌟</p><p><strong><em>References and Links</em></strong></p><p>⭐ Concurrency in Go, <a href="https://learning.oreilly.com/search/?query=author%3A%22Katherine%20Cox-Buday%22&amp;sort=relevance&amp;highlight=true">Katherine Cox-Buday</a></p><p>⭐ <a href="https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html">Concurrent and Parallel Programming, Joe Armstrong</a></p><p>⭐ <a href="https://www.golangprograms.com/go-language/concurrency.html">Golang Concurrency</a></p><p>⭐ <a href="https://www.golang-book.com/books/intro/10">Concurrency</a></p><p>⭐ Concurrent Programming with Go, By <a href="https://app.pluralsight.com/profile/author/mike-vansickle">Mike Van Sickle</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23ba18e8ff65" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Api Gateway (w/Ocelot)]]></title>
            <link>https://handeebrar.medium.com/api-gateway-w-ocelot-38a8ff120bda?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/38a8ff120bda</guid>
            <category><![CDATA[api-gateway]]></category>
            <category><![CDATA[dotnet-core]]></category>
            <category><![CDATA[api-management]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Tue, 22 Feb 2022 13:47:20 GMT</pubDate>
            <atom:updated>2022-02-22T13:48:50.095Z</atom:updated>
            <content:encoded><![CDATA[<p>Api Gateway; özellikle microservice mimarisi gibi kompleks servislerin client’lara tek bir noktadan açılmasını sağlayarak ters proxy görevi gören api management aracıdır. Client üzerinden aldığı isteği uygun backend servisine iletir ve servislerden almış olduğu response’ları aggregate ederek client’a gönderir. Bu sayede client’ın, her bir service için ayrı ayrı istekler göndermesi yerine sadece Api Gateway ile haberleşmesi yeterli olacaktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-pdD_xTq6sG1IppK4-JpWg.png" /></figure><p>Api Gateway authentication, metric collection, input validation, response transformation gibi önemli yönetim ve güvenlik işlemlerini de destekler.</p><p><strong>Authentication</strong></p><p>Client’ın birden fazla serviste bulunan verilere erişmesi gerekse bile, Api Gateway’de yalnızca bir kez authentication yapması yeterli olacaktır. Bu sayede latency azalır ve authentication işleminin uygulama genelinde tutarlı olması sağlanır.</p><p><strong>Metrics Collection</strong></p><p>Tüm istekler Api Gateway’den geçtiğinden dolayı analiz için veriler buradan elde edilebilir. Herhangi bir saldırıyı engellemek adına istekleri sınırlamak için de kullanılabilinir.</p><p><strong>Input Validation</strong></p><p>Gelen isteklerin başarılı bir şekilde tamamlanabilmesi için gerekli kontrolleri sağlar. Bir şeyler ters görünüyorsa, Api Gateway isteği servislere iletmeden reddedecektir.</p><p><strong>Response Transformation</strong></p><p>Api Gateway gerektiğinde response için bir nevi translator görevi görür. Örneğin, JSON formatında veriye ihtiyaç duyan bir client ile XML formatında response dönen bir backend servisi Api Gateway sayesinde iletişim kurabilir. Farklı uygulamalar ve kullanıcılar genellikle farklı bilgilere erişmeye ihtiyaç duyar. Mobil uygulamalar genellikle web uygulamalarına göre daha az veriye ihtiyaç duyar. Böylece Api Gateway gelen isteklere doğru response’ları sağlayabilir.</p><p><strong>Ocelot</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*C77QekLdKiaVRaftrdzeOw.jpeg" /></figure><p>.NET Core tabanlı ve micro service mimarisi için tasarlanmış, open-source Api Gateway kütüphanesidir. Ocelot, Api Gateway’e gelen isteği konfigürasyonlara göre hedef servise yönlendirir ve oradan aldığı response’u client’a döner.</p><p>Aşağıda Ocelot ile yaptığım PoC çalışmasına ait diagram bulunmaktadır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*GBt9-WpQqUHkYbqNoIAfMg.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a17c58d519864989aaebb70594a25329/href">https://medium.com/media/a17c58d519864989aaebb70594a25329/href</a></iframe><p>DownstreamPathTemplate, DownstreamScheme ve DownstreamHostAndPorts, request’in iletileceği servisin URL’ini oluşturur.</p><p>UpstreamPathTemplate, client’tan gelen belirli bir request için hangi DownstreamPathTemplate’in kullanılacağını belirler.</p><p>Client’tan gelen request’ler Api Gateway’de Ocelot config’lerine göre Customer Api ve Reservation Api’lara yönlendirilmekte. Böylece client’ların backend servisleriyle ilgili herhangi bir port bilgisini bilmesine gerek kalmamaktadır.</p><p>Ocelot ile Routing dışında Request Aggregation, Authentication, Authorization, Rate Limiting, Caching, Load Balancing, Logging, Tracing gibi bir çok işlem yapabilirsiniz.</p><p>Vakit ayırıp okuduğunuz için teşekkür ederim. ✨</p><p><strong>References and Links</strong></p><ul><li><a href="https://docs.microsoft.com/en-us/dotnet/architecture/microservices/multi-container-microservice-net-applications/implement-api-gateways-with-ocelot">Implementing API Gateways with Ocelot</a></li><li><a href="https://ocelot.readthedocs.io/en/latest/">Welcome to Ocelot - Ocelot 1.0.0 documentation</a></li><li><a href="https://github.com/ThreeMammals/Ocelot">GitHub - ThreeMammals/Ocelot: dotnet 7.0 API Gateway</a></li><li><a href="https://github.com/handeebrar/api-gateway-ocelot">GitHub - handeebrar/api-gateway-ocelot: API gateway implementation with Ocelot</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38a8ff120bda" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CQRS & Mediator Pattern in .Net Core]]></title>
            <link>https://handeebrar.medium.com/cqrs-mediator-pattern-in-net-core-ed21dffc8e77?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed21dffc8e77</guid>
            <category><![CDATA[cqrs]]></category>
            <category><![CDATA[mediatr]]></category>
            <category><![CDATA[mediator]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Sun, 02 May 2021 16:26:47 GMT</pubDate>
            <atom:updated>2021-05-02T16:34:44.006Z</atom:updated>
            <content:encoded><![CDATA[<h3>CQRS &amp; Mediator Pattern in .Net Core</h3><p>Yine yeni yeniden bir karantina yazısından daha herkese merhaba 👽</p><p>Bu yazıda CQRS’in çözüm getirdiği problemlerden, Mediator pattern ve MediatR kütüphanesinden bahsedeceğim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-SzVMSCaO67p9pmR0r6gZw.png" /></figure><h3><strong>Problem</strong></h3><p>Geleneksel mimarilerde, veritabanını sorgulamak ve güncellemek için aynı veri modeli kullanılır. Bu yaklaşım temel CRUD işlemleri için iyi çalışır. Fakat uygulama karmaşıklığı arttıkça, çok fazla sorumluluğa sahip aşırı kompleks modeller elde edilebilir. Bu durum da beraberinde bazı problemler getirir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/349/1*2k3di0WZPrlYoVsGfiLs_Q.png" /></figure><p>❌Read ve write işlemlerinde aynı model kullanıldığından mevcut işlem için gerekli olmayan alanların da güncellenmesi gerekir.</p><p>❌İşlemler aynı veri kümesi üzerinde paralel olarak gerçekleştirildiğinde sistem üzerindeki lock olasıkları artar.</p><p>❌Sorguların karmaşıklığının veri erişim katmanında oluşturduğu yük nedeniyle performans üzerinde olumsuz etkilere neden olabilir.</p><p>❌Read ve write işlemleri performans ve ölçeklenebilirlik gereksinimleri açısından farklılık gösterir.</p><h3>Solution</h3><p><strong>CQRS</strong> <em>(Command Query Responsibility Segregation)</em>, her eylemi net bir şekilde ayırıp kendi response modellerini döndürerek; write işlemlerini read işlerinden ayırmaya olanak tanıyan bir tasarım desenidir. Verileri güncellemek için <strong>command</strong>’ları, okumak için <strong>query</strong>’leri kullanır. Command ve query’ler için bazı detaylar:</p><p>✔️Command’lar veri odaklı değil, göreve dayalı olmalıdır. (“set ReservationStatus to Reserved” yerine “Book hotel room”)</p><p>✔️Command’lar sync yerine async işlenmek için bir queue’da yer alabilirler.</p><p>✔️Query’ler veritabanındaki veriler üzerinde bir değişiklik yapmaz. Query, herhangi bir domain bilgisi içermeyen bir DTO döndürür.</p><p>Ayrı command ve query modellerine sahip olmak, tasarımı ve uygulamayı sadeleştirir. Sağladığı avantajların yanında bazı implementasyon zorluklarını da unutmamak gerekir:</p><p>🔸 <em>Complexity:</em> CQRS’nin temel fikri basittir. Ancak, <a href="https://martinfowler.com/eaaDev/EventSourcing.html">Event Sourcing</a> pattern içeren uygulamalarda daha karmaşık bir tasarıma neden olabilir.</p><p>🔸<em>Messaging:</em> CQRS mesajlaşma gerektirmese de, command’ları işlemek ve update event’lerini yayınlamak için mesajlaşmanın kullanılması yaygındır. Bu durumda, uygulamanın mesaj hatalarını veya duplicate mesajları handle etmesi gerekir.</p><p>🔸<em>Eventual consistency:</em> Read ve write veritabanları ayrılırsa, okunan veriler güncel olmayabilir.</p><p>Farklı modelleri yönetmek zorunda kalmanın getirdiği karmaşıklık konusunda yardımcı olabilecek bir tasarım deseni: <em>Mediator pattern</em>.</p><p><strong>Mediator,</strong> nesneler arasındaki karmaşık bağımlılıkları azaltmaya yarayan bir tasarım desenidir. Nesneler arasındaki doğrudan iletişimi kısıtlar ve yalnızca bir mediator nesnesi aracılığıyla işbirliği yapmaya zorlar. Nesneler sadece meditor objesini bilir ve onunla iletişime geçer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*hoq3cirWVKv4UuYocYCPaw.png" /></figure><p>Havaalanı kontrol alanına yaklaşan veya alandan çıkan pilotlar birbirleriyle doğrudan iletişim kurmazlar. Bunun yerine, uçak pistine yakın bir yerde yüksek bir kulede bulunan hava trafik kontrolörü ile konuşurlar. Hava trafik kontrolörü olmadan pilotların, birbirleri ile konuşup iniş önceliklerini tartışarak havalimanının çevresindeki her uçağın farkında olmaları gerekirdi. Bu muhtemelen uçak kazası istatistiklerini arttırırdı.</p><p><a href="https://github.com/jbogard/MediatR"><strong>MediatR</strong></a><strong>,</strong> mediator deseninin open source bir uygulamasıdır. Sync veya async kalıplar kullanarak mesaj oluşturmaya, event’ler oluşturmaya/dinlemeye olanak tanır.</p><p>İmplementasyonu gerçekleştirmek için iki parçaya ihtiyacımız olacak: yapmamız gerekeni içeren bir <strong>message/request </strong>ve mesajı işlemek için logic içeren <strong>handler</strong>. MediatR’da bunun için IRequest ve IRequestHandler’ı kullanırız.</p><p>Yazının devamında bu kavramları, tamamını Github’ta paylaştığım Ticket Management Application kodları üzerinden anlatacağım.</p><p><a href="https://github.com/handeebrar/ticket-management">handeebrar/ticket-management</a></p><p>Uygulama içerisindeki bazı nesneler/controller tüm kategorilerin bir listesine erişmek istemektedir. Bu nesneler arası bir iletişim, dolayısıyla bir mesaj olmalıdır. Döndürülecek türde parametre alan, generic IRequest interface’ini uygulayan bir query sınıfı oluştururuz. Bu yukarıda bahsettiğim <strong>message </strong>kısmıdır:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fe361336eb652630e9f6928ab0fa1e53/href">https://medium.com/media/fe361336eb652630e9f6928ab0fa1e53/href</a></iframe><p>Peki nasıl handle edilecek? Yukarıda oluşturduğumuz IRequest türü için bir request <strong>handler </strong>yazmamız gerekecek. Mesaj alındığında interface içerisinde bulunan Handle() metodu çağrılacak ve bu örnekte tüm kategorilerin listesini tutan repository kullanılarak CategoryListViewModel dönülecektir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/846e48c0d26bd6bdfd0775bd79894335/href">https://medium.com/media/846e48c0d26bd6bdfd0775bd79894335/href</a></iframe><p>Peki bu request ve handler’ı nasıl kullanacağız? Tek yapmamız gereken controller’da mediator’ı inject edip query’i göndermek.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee56872ac4d42f289f901ca87db69ebb/href">https://medium.com/media/ee56872ac4d42f289f901ca87db69ebb/href</a></iframe><p>CQRS mimarisinin temelinden ve MediatR ile nasıl uygunabileceğinden bahsetmeye çalıştım. Vakit ayırıp okuduğunuz için teşekkür ederim.</p><p>Sağlıklı günler! 🙏</p><h3>Sources</h3><ul><li><a href="https://docs.microsoft.com/en-us/azure/architecture/patterns/cqrs">CQRS pattern - Azure Architecture Center</a></li><li><a href="https://martinfowler.com/bliki/CQRS.html">bliki: CQRS</a></li><li><a href="https://refactoring.guru/design-patterns/mediator">Mediator</a></li></ul><p><a href="https://app.pluralsight.com/library/courses/13d82055-6db2-47b1-8ed1-e939f97d380a/table-of-contents">Architecting ASP.NET Core Applications: Best Practices By Gill Cleeren</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed21dffc8e77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GoLang : Structs (with/out Pointers)]]></title>
            <link>https://handeebrar.medium.com/golang-structs-with-out-pointers-5e86f0674a55?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e86f0674a55</guid>
            <category><![CDATA[pointers]]></category>
            <category><![CDATA[türkçe-kaynak]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[structure]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Tue, 26 Jan 2021 07:31:48 GMT</pubDate>
            <atom:updated>2021-01-26T07:31:48.708Z</atom:updated>
            <content:encoded><![CDATA[<h3>GoLang : Structs (with/out Pointers)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k54XMTDxknLwLfbcrxHb6A.png" /></figure><p>Go öğrenme yolculuğumda, hem kendime hem de ilgilenenlere kaynak olması için yazmış olduğum bir yazıdan daha herkese merhaba 🥳</p><p>Başlık yeterince kafa karıştırdıysa 🤯, bu yazıda Go’daki structures, pointers kavramlarından ve birlikte kullanımlarından bahsediyor olacağımı belirtip başlayabilirim.</p><h4>Structs/Structures</h4><p>Object-Oriented Programming’in aksine, Go’da class-object mimarisi yoktur. Bunun yerine, karmaşık veri yapılarını bir arada tutmayı/gruplandırmayı sağlayan struct’lar vardır.</p><p>Struct tanımlamak için, isminin önüne <em>type </em>ve sonuna da <em>struct</em> keyword’lerini eklememiz gerekir. Bir struct int, string türündeki alanlardan oluşabileceği gibi içerisinde farklı türde struct alanlar da bulundurabilir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c0b98200dd9579c1ce31e883f787ffb2/href">https://medium.com/media/c0b98200dd9579c1ce31e883f787ffb2/href</a></iframe><p>Struct’lar için fonksiyon tanımlamaları da yapabiliriz. Örneğin aşağıda isim güncellemesi yapan ve Person tipinde bir receiver fonksiyon tanımladık.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c11d6e1461cddd44fc87833b2a3cd00/href">https://medium.com/media/7c11d6e1461cddd44fc87833b2a3cd00/href</a></iframe><p>FirstName alanı “Ada” olarak initiliaze edilen person’ı, FirstName’i “Augusta” olarak güncellediğimiz dolayısıyla “Augusta Lovelace” çıktısını vermesini beklediğimiz kodu çalıştırdığımızda (⌛️ heyecanı arttırmak için burada biraz oyalayayım sizi tamam yeterli⏳) console ekranında “<strong>Ada </strong>Lovelace” yazdığını görüp ufak bir şaşkınlık yaşarız.</p><h4>Pass By Value</h4><p>FirstName alanının niçin fonksiyona gönderilen parametreyle değiştirilmediğine geçmeden önce bilgisayarlarımızda bulunun RAM’in çalışma mantığıyla ilgili ufak bir hatırlatma yapmak istiyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/282/1*SFviCspZf0ZZ2pYEbCchVA.png" /></figure><p>Bilgisayardaki belleği birçok küçük kutudan oluşuyormuş gibi düşünelim. Bu küçük kutuların birbirinden farklı adresleri vardır. Bu yüzden yazdığımız program “Bilgisayarın belleğinden bazı bilgileri almak istiyorum.” dediği bir adres bulur ve değeri o adresten alır.</p><p>Şimdi yukarıda yazdığımız programın bilgisayarımızdaki RAM ile nasıl çalıştığını inceleyelim. İlk olarak Person tipinde bir struct oluşturduğumuzda ve onu person değişkenine atadığımızda Go struct’ı oluşturur. Daha sonra belleğe gider ve bu değeri yerleştirebileceği bir alan seçer. Böylece person struct’ının şekildeki 0001 adresine konumlandırıldığını düşünebiliriz. person doğrudan bu küçük kutuyu işaret ediyor. Ve person değerini programda yazdırdığımızda her zaman tam olarak 0001 adresindekini değerini göreceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*An5lapOzmJkDpBJH2CGruA.png" /></figure><p>Şimdi person.UpdateNameInformation() fonksiyonu çağırdığımızda neler olacağını inceleyelim. İşler burada biraz tuhaflaşıyor. Go “<em>pass by value</em>” yaklaşımına sahip bir dildir. Bir fonksiyona bir değer/struct ilettiğimizde Go o struct’un içerisindeki tüm verileri kopyalar ve belleğin içerisinde yeni bir kutuya yerleştirir (0003). Bu yüzden person’a yeni bir FirstName değeri ilettiğimizde person’un FirstName’i 0001 adresinde “<em>Ada</em>” olarak var olmaya devam eder. UpdateNameInformation() fonksiyonu receiver olarak p aldığı için FirstName’e ait güncellemeyi de 0003 adresindeki değerde yapar. Dolayısıyla çıktı olarak “<em>Ada</em>” görmemizin sebebi, güncellemeyi kopya olan 0003 adresindeki FirstName için yapıp, ekrana 0001 adresindeki FirstName’in değerini yazdırıyor olmamızdır.</p><p>Peki değişikliği fonksiyonun receiver olarak kabul ettiği struct’ta nasıl yapacağız? “Hadi devvvam edelim!”</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FejUb7Rpm6pM%3Fstart%3D7%26feature%3Doembed%26start%3D7&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DejUb7Rpm6pM&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FejUb7Rpm6pM%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/81b9a97af47ca2802c4482b27ab884a2/href">https://medium.com/media/81b9a97af47ca2802c4482b27ab884a2/href</a></iframe><h4>Pointer Operations</h4><p>Update işleminin person üzerinde yapılması için kodda bazı değişiklikler yapalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/896e7256bd68c9f81349147a3ac7aa1e/href">https://medium.com/media/896e7256bd68c9f81349147a3ac7aa1e/href</a></iframe><p>Kodu çalıştırdığımızda console ekranında (⌛️ bu sefer daha kısa tutuyorum⏳) “<strong>Augusta </strong>Lovelace” yazdığını görünce bir taraftan sevinirken bir taraftan da soru işaretleri oluşmaya başladığını görür gibiyim. Bu yüzden ilk olarak 11. satırdaki <strong>&amp;</strong> ve 18–19. satırlardaki <strong>*</strong> operatörlerinin ne anlama geldiklerini açıklayayım.</p><p><strong>&amp;</strong>value→ Değişkenin işaret ettiği değerin bellekteki adresini verir.</p><p>*address→ Hafıza adresinin (person address) işaret ettiği değeri verir.</p><p>Burada fonksiyon tanımlamasındaki *Person ile fonksiyon içerisinde yer alan *pointerToPerson’ın başındaki * operatörü farklı anlam içermektedir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/743fc3621648b09b213c3916105e59db/href">https://medium.com/media/743fc3621648b09b213c3916105e59db/href</a></iframe><p>*Person → Type description — person pointer’ı ile çalıştığımız anlamına gelir.</p><p>*pointerToPerson → Operator — pointer’ın referans verdiği değeri değiştirmek istediğimiz anlamına gelir.</p><h4>Pointer Shortcut</h4><p>Go’da yukarıda açıkladığımız kod ile aynı sonucu veren bir kısayol mevcut.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6635d29afe66f822ea93b67f671b3437/href">https://medium.com/media/6635d29afe66f822ea93b67f671b3437/href</a></iframe><p>11. satırdaki personPointer’ı person’a çevirdiğimizde, bu kısayol sayesinde receiver olarak person’a ait pointer (*Person) alan bir fonksiyona, Person türünden bir değişken (person) ile erişebiliyoruz. Go bizim için person değişkenini, person pointer’ına dönüştürüyor. 💯</p><p>Struct ve pointer kavramlarının ne olduğu, ne zaman kullanılması gerektiğinden bahsetmeye çalıştım. Vakit ayırıp okuduğunuz için teşekkür ederim. ✨</p><p>🏃‍♀️ Az kalsın söylemeyi unutuyordum… Yukarıda yazdığımız kodda ismi geçen gerçek adı Augusta Ada Byron olan mucit, tüm dünya tarafından gerçek adıyla değil Ada Lovelace ismiyle bilinmektedir. <a href="https://emojipedia.org/woman-running/">🏃‍♀️</a></p><h3>Kaynaklar</h3><p>📚 Go Design Patterns , Mario Castro Contreras</p><p><a href="https://emojipedia.org/laptop/">💻</a> Master the fundamentals and advanced features of the Go Programming Language (Golang) , <em>Stephen Grider</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e86f0674a55" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GoLang : “Hello World!”]]></title>
            <link>https://handeebrar.medium.com/golang-hello-world-9eeca1d374f4?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/9eeca1d374f4</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[türkçe-yayın]]></category>
            <category><![CDATA[turkce-yayin]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Sat, 19 Dec 2020 22:02:44 GMT</pubDate>
            <atom:updated>2020-12-19T22:02:44.541Z</atom:updated>
            <content:encoded><![CDATA[<h3>GoLang : “Hello World!”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*V8n7h-ENjx8Qo2r4k2pVig.png" /></figure><p>Yeni bir programlama dili öğrenmeye, genellikle bir gelenek haline gelmiş olan “Hello World!” programını yazarak başlarız. Ben de bu yazımda Go ile yazılmış basit bir “Hello World” uygulamasının perde arkasında nasıl çalıştığına dair yapmış olduğum araştırmaları ve notlarımı sizinle paylaşıyor olacağım.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e90bb95d17cd9c1e89fd07cc02c1364/href">https://medium.com/media/1e90bb95d17cd9c1e89fd07cc02c1364/href</a></iframe><h4><strong><em>Run the code</em></strong></h4><blockquote>$ go run hello.go</blockquote><p><strong><em>“run”</em></strong> komutu, parametre olarak almış olduğu dosyadaki tüm kodu geçici bir dizinde derler, ardından sonucu çalıştırır ve çalıştırılabilir bir dosya oluşturmaz. Eğer programın sadece derlenmesini ve böyle bir dosyanın oluşturulmasını istiyorsak <strong><em>“build”</em></strong> komutunu kullanmamız gerekir.</p><blockquote>$ go build hello.go</blockquote><blockquote>$ ./hello</blockquote><p>GO CLI’ya bağlı diğer bazı yaygın komutlar:</p><ul><li>go fmt → Bulunduğu dizinde her dosyadaki tüm kodu biçimlendirir.</li><li>go install → Bir paketi derler ve bin’e ekler.</li><li>go get → Başka bir paketin kaynak kodlarını indirir.</li><li>go test → Mevcut projeyle ilgili tüm testleri çalıştırır.</li></ul><h4>Packages</h4><p>Bu kısımda hello.go dosyasındaki ilk satırdan bahsedeceğim. Package, ortak kaynak kod dosyalarının bir koleksiyonudur.</p><blockquote>Package = Project = Workspace</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/823/1*UiEYMzzlAcgcua14EYDj7Q.jpeg" /></figure><p>Package içerisinde go uzantısına sahip birçok dosya bulunabilir. Buradaki tek gereksinim her dosyanın ilk satırında ait olduğu package’ın bildirilmesidir. Go’da iki farklı package türü vardır.</p><ol><li><em>Executable type : </em>Yukarıdaki örnekte yaptığımız gibi derlendiğinde çalıştırılabilir veya exe dosyası ortaya çıkarır. Çalıştırabilir bir dosya oluşturmak istiyorsak kodumuza main package’ını ve main fonksiyonunu eklemeliyiz. (package <strong>main</strong>)</li><li><em>Reusable type : Ç</em>alıştırılabilir bir dosya oluşturmak yerine farklı projelerde bazı kodları yeniden kullanmamıza yardımcı olacak kod bağımlılıkları veya helper olarak düşünebileceğimiz package’lardır. (package calculator, package uploader, …)</li></ol><h4>Import Statements</h4><p>Bu kısımda hello.go dosyasındaki üçüncü satırdan bahsedeceğim. Import ifadesi o anda yazdığımız kodun, başka bir package içerisinde yazılmış olan koda erişmesini sağlar.</p><p>fmt, Go diline dahil olan biçimlendirmeye yarayan standart bir library’dir. Kodumuza “import fmt” satırını eklemek, fmt package’ının içinde bulunan tüm fonksiyonelliğe erişim vermek anlamına gelir. Özetle, kendi package’ımızdan diğerlerine bir bağlantı oluşturmak için import ifadesini kullanırız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/338/1*rmZsrIgfV3gVwn5K-2k_qg.png" /></figure><h4>Functions</h4><p>Kod örneğimizdeki beşinci satırda bulunan <strong><em>“func main”</em></strong> kısmı diğer programlama dillerindeki fonksiyonlarla aynı işlevi görmektedir.</p><blockquote>A function must do just one thing, but it must do it damn well.</blockquote><p>Fonksiyon , kendi değişkenleri ve akışı olan, açılış ve kapanış parantezleri dışındaki hiçbir şeyi etkilemeyen kod parçasıdır. main() fonksiyonu, Go’daki çalıştırılabilir bir programın giriş noktasıdır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/81bcee26e01cab0eb15c55d489d730de/href">https://medium.com/media/81bcee26e01cab0eb15c55d489d730de/href</a></iframe><p>Basit bir hello world programıyla Go’daki bazı temel konulardan bahsetmeye çalıştım. Vakit ayırıp okuduğunuz için teşekkür ederim. 🥳</p><h4>Kaynaklar</h4><p>📚 Go in Practice: Includes 70 Techniques , <em>Matt Butcher and Matt Farina</em></p><p>📚 Go Design Patterns , Mario Castro Contreras</p><p><a href="https://emojipedia.org/laptop/">💻</a> Master the fundamentals and advanced features of the Go Programming Language (Golang) , <em>Stephen Grider</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9eeca1d374f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Traditional N-Layer Architecture X Clean Architecture]]></title>
            <link>https://handeebrar.medium.com/traditional-n-layer-architecture-x-clean-architecture-2b35f5aa0187?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b35f5aa0187</guid>
            <category><![CDATA[türkçe-yayın]]></category>
            <category><![CDATA[onionarchitecture]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Sun, 28 Jun 2020 21:56:47 GMT</pubDate>
            <atom:updated>2020-06-29T08:14:22.602Z</atom:updated>
            <content:encoded><![CDATA[<p>Selamlar 🐣,</p><p>Bu yazımda, geçen hafta Devnot tarafından gerçekleştirilen <a href="https://www.youtube.com/watch?v=aWOHq6AHNjU">Online Microservices &amp; DDD Konferansı</a>‘na katıldıktan sonra daha da dikkatimi çeken ve projelerimde kullanmak için hakkında araştırmalar yaptığım Clean Architecture’dan bahsetmeye çalışacağım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*7xHIB2SDdMQr7RySMRVDzw.gif" /></figure><p>Karmaşıklığı gitgide artan uygulamalardaki yapıyı yönetmek ve değişimi kolaylaştırmak adına belirli bir standarda ve düzene ihtiyaç duyulmaktadır. Bu karmaşıklığı yönetmenin bir yolu, uygulamadaki modülleri işlev ve özelliklerine göre ayırmaktır. Kodun katmanlar halinde düzenlenmesi, uygulama genelinde reusability’i arttırır ve kod tekrarlarının önüne geçilmesine yardımcı olur (<em>Don’t Repeat Yourself</em>). Katmanlı mimari, kodun organizasyonunu iyileştirmek için yaygın olarak kullanılan bir tekniktir. Kodun katmanlar halinde organize edilmesinin birkaç yolu vardır:</p><h4>Klasik N-Katmanlı Mimari</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NsB5BVxI4AY_lRFhEfZlGg.png" /></figure><p>Bu katmanlar genellikle User Interface (UI), Business Logic Layer (BLL) ve Data Access Layer (DAL) olarak adlandırılır. İhtiyaç doğrultusunda katmanların sayısı çoğaltılabilir. Bu mimarinin amacı, her katmanın kendine özgü sorumluluğunun belirlenmesini sağlamaktır.</p><blockquote><strong>Separation of Concerns: </strong>Farklı kod sorumluluklarını aynı ( metod | sınıf| proje )‘de karıştırmaktan kaçının.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xwjVnRuLZ_vnpihZvMvdng.png" /></figure><p>Bu mimari yaklaşımının bir dezavantajı, bağımlılıklarının yukarıdan aşağıya doğru gitmesidir.</p><p>Yani kullanıcı arayüzü, veri erişim katmanına bağımlı olan iş kurallarını içeren katmana bağımlıdır. Bu da genellikle uygulamadaki en önemli mantığı barındıran BLL’in bir veritabanına bağımlı olduğu anlamına gelir.</p><h4>(Clean || Onion || Hexagonal) Architecture || Ports and Adapters</h4><p>Clean Architecture, iş mantığını ve uygulama modelini uygulamanın merkezine yerleştirir. Arkasındaki ana prensiplerden birisi, <em>Dependency Inversion</em> prensibidir. İş mantığının, veri erişimine veya diğer altyapı concern’lerine bağlı olması yerine, bu bağımlılık tersine çevrilir: Altyapı ve uygulama concern’leri uygulama çekirdeğine (application core) bağımlıdır. Bu, uygulama çekirdeğinde soyutlamalar veya arayüzler tanımlayarak elde edilir. Bu mimariyi görselleştirmenin yaygın bir yolu, soğana benzer şekilde iç içe daireler kullanmaktır. (Onion Architecture)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*T8LGLTDtEkNouUoD.png" /></figure><p>İçteki daire, uygulamanızın <strong>Domain </strong>katmanıdır. Burası iş kurallarını (<em>business rules </em>— uygulamanızın yaptığı şeyin özü, kodun temel işlevselliği) belirlediğimiz yerdir. Örneğin bir e-ticaret uygulamasında sipariş verme gibi uygulamanızın çok sık yaptığı şeyi değiştirme olasılığınız olmadığından bu iş kuralları oldukça kararlı olma eğilimindedir.</p><p>Dıştaki daire <strong>Infrastructure</strong>’dır. Kullanıcı arayüzü, veritabanı, web servisleri ve framework gibi bileşenleri içerir. Bu bileşenlerin Domain’den daha fazla değişme olasılığı vardır. Örneğin, arayüzdeki bir butonun tasarımını değiştirmek gibi.</p><p>Domain ve Infrastructure arasında bir sınır oluşturulur. Böylece Domain, Infrastructure hakkında hiçbir şey bilmez. Bu, arayüz ve veritabanının iş kurallarına bağımlı olduğu, ancak iş kurallarının arayüz veya veritabanına bağımlı olmadığı anlamına gelir. Bu da onu bir <em>plug-in</em> mimarisi yapar. Domain için kullanıcı arayüzünün bir web arayüzü, masaüstü uygulaması veya mobil uygulama olması, verilerin SQL veya NoSQL kullanılarak mı yoksa bulutta mı saklandığı önemli değildir. Bu da gerektiği zaman Infrastructure’ı değiştirmeyi kolaylaştırır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*bi_64HAbR5eaXuaU.png" /></figure><p>Burada Domain katmanı <em>Entity </em>ve <em>Use Case</em> olarak ayrılabilir ve bir <strong>Adapter </strong>katmanı, Domain ile Infrastructure katmanı arasındaki bahsettiğimiz sınırı oluşturur. Bu kavramları kısaca açıklamaya çalışalım:</p><ul><li><strong>Entities </strong>: Uygulamanın fonksiyonelliği için kritik olan iş kuralları kümesi. Diğer katmanlar ile ilgili hiçbir şey bilmezler ve bağımlılıkları yoktur.</li><li><strong>Use Cases</strong> : Uygulamanın davranışını belirleyen iş kurallarıdır. Entities ile etkileşime girer ve bunlara bağımlıdır, ancak diğer katmanlar hakkında bir şey bilmezler. Onun için uygulamanın bir web sayfası mı yoksa iPhone uygulaması mı olduğu önemli değildir. Ayrıca dış katmanların kullanacağı interface ve abstract class’lar bu katmanda tanımlanır.</li><li><strong>Adapters </strong>: Interface adapters olarak da adlandırılan adapters, domain ile infrastructure arasındaki tercümanlardır. Örneğin, verileri arayüzden alırlar. Use case ve entity için uygun bir biçimde yeniden paketlerler. Daha sonra çıktıyı use case ve entity’lerden alır ve bunu arayüzde görüntülemek veya bir veritabanına kaydetmek için uygun bir biçimde yeniden paketler.</li><li><strong>Infrastructure : </strong>Bu katman, tüm I/O bileşenlerinin bulunduğu yerdir: Kullanıcı arayüzü, veritabanı, framework, cihazlar vb. Bu katmandaki şeylerin değişme olasılığı yüksek olduğundan, daha kararlı olan katmanlardan mümkün olduğunca uzak tutulurlar. Ayrı tutulduklarından dolayı değişiklik yapmak nispeten kolaydır.</li></ul><h4>Clean Architecture Özellikleri</h4><ul><li><em>Dil bağımsız </em>— Bu mimariyi C#, Java, Python vb. ile kullanabilirsiniz çünkü herhangi bir kütüphaneye veya özel kod tabanına bağımlı değildir.</li><li><em>Veritabanı bağımsız </em>— Kodun büyük çoğunluğu, uygulama tarafında hangi veritabanının kullanılabileceği hakkında bir bilgiye sahip değildir.</li><li><em>Arayüz bağımsız </em>— Kullanıcı arayüzünü yalnızca UI projesi önemser. Sistemin geri kalanı bununla ilgilenmez.</li><li><em>Test edilebilir</em> — Bu mimari kodunuzu çok daha test edilebilir hale getirebilir. Fazla bağımlılıklar içeren kodu test etmek zordur. Ancak bir plug-in mimarisine sahip olduğunuzda, bir veritabanı bağımlılığını (veya herhangi bir bileşeni) mock data ile değiştirmek daha kolaydır.</li></ul><p>Clean Architecture aynı anda ve aynı nedenden ötürü değişebilecek sınıfların, bileşenler halinde gruplandırılması gerektiğine dayanır. İş kuralları, altyapı bileşenlerine göre daha kararlıdır ve diğer ayrıntılarla ilgilenen daha değişken olan bu altyapı bileşenleri hakkında hiçbir şey bilmemelidir. Katmanlar arasındaki sınır, katmanlar arasındaki verileri çeviren ve bağımlılıkları daha kararlı olan iç bileşenlerin yönüne işaret eden adapter kullanılarak korunur.</p><p>Bu mimari ile ilgili edindiğim bilgileri ve notlarımı faydalı olabilmek adına sizlerle de paylaşmak istedim. Buraya kadar okuduğunuz için teşekkür ederim.</p><p>Sağlıklı günler 🎈</p><h4>Kaynaklar</h4><ul><li><a href="http://online.devnot.com/">Online Microservices &amp; Domain Driven Design Konferansı</a></li><li><a href="https://docs.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures">Common web application architectures</a></li><li><a href="https://pusher.com/tutorials/clean-architecture-introduction">Clean architecture for the rest of us</a></li><li><a href="https://www.gokhan-gokalp.com/getting-started-with-clean-architecture-using-asp-net-core-01/">Getting Started with Clean Architecture using ASP.NET Core - 01</a></li></ul><iframe src="https://drive.google.com/viewerng/viewer?url=https%3A//devintxcontent.blob.core.windows.net/showcontent/Speaker%2520Presentations%2520Fall%25202017/Clean%2520Architecture%2520with%2520ASP.NET%2520Core.pdf&amp;embedded=true" width="600" height="780" frameborder="0" scrolling="no"><a href="https://medium.com/media/105b5c465ea11b283e194da0c73bad54/href">https://medium.com/media/105b5c465ea11b283e194da0c73bad54/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b35f5aa0187" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C#’ta Value Type ve Reference Type]]></title>
            <link>https://handeebrar.medium.com/c-ta-value-type-ve-reference-type-178d3a5823ac?source=rss-604ec5d274c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/178d3a5823ac</guid>
            <category><![CDATA[value-type]]></category>
            <category><![CDATA[türkçe-yayın]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[reference-type]]></category>
            <dc:creator><![CDATA[Hande Ebrar Gunesdogdu]]></dc:creator>
            <pubDate>Sun, 26 Apr 2020 21:43:07 GMT</pubDate>
            <atom:updated>2020-04-27T09:55:40.053Z</atom:updated>
            <content:encoded><![CDATA[<p>Merhabalar,</p><p>Bu yazımda kod yazarken sıklıkla kullandığımız değişkenler ve nesnelerin aslında ne olduklarına, nerelerde tutulduklarına ve farklarına değinmek için Value Type ve Reference Type kavramlarını ele alacağım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*GXoMWqljArmbjB0ReNioag.gif" /></figure><p>C# dilinde veri tipleri, <strong>value type</strong> ve <strong>reference type</strong> olmak üzere ikiye ayrılır. Bildiğimiz üzere değişkenler, bellekte tutulan verilerdir. Bir değişkeni kullanırken aslında o değişkenin, bellekte tutulduğu adresindeki veriye ulaşırız. Value type’lar değişkenin değerini direkt olarak bellek bölgesinden alırken, reference type’lar ise başka bir nesneye referans olarak kullanılırlar. Value type’lar stack dediğimiz bellek bölgelerinde oluşturulurlar, reference type’lar ise heap alanında oluşturulan veri türlerinin (nesnelerin) adreslerini saklarlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/0*qpNhTAPBr5mdIAgY" /></figure><p>Temel veri tipleri olan int, double, float ve struct gibi veri türleri value type; herhangi bir sınıf türü ise (string, object) reference type’tır.</p><p>İki value type nesnesini birbirine eşitlerken değişkenlerde saklanan değerler kopyalanarak eşitlenir ve bu durumda iki yeni bağımsız nesne elde edilmiş olur yani birinin değerini değiştirmek diğerini etkilemez.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5cae754ecbb9442a8478b57ba5ce494/href">https://medium.com/media/e5cae754ecbb9442a8478b57ba5ce494/href</a></iframe><p>Ancak iki reference type’ı birbirlerine eşitlediğimizde bu nesnelerde tutulan veriler kopyalanmaz, işlem yapılan nokta nesnelerin heap bölgesindeki adresleridir, yani iki nesne de aslında heap bellek bölgesinde aynı adresi gösterecekleri için birinde yapılan değişiklik diğerini de etkileyecektir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*XUkvFABnov7iJ6zh.jpg" /></figure><p>C# dilinde önceden tanımlanmış iki tane temel reference type vardır: string ve Object.</p><p>Object, C#’ta bütün veri türlerinin türediği bir veri türüdür. Her nesne bir object olduğu için bütün değerler ve nesneler object türünden bir değişkene atanabilir.</p><p>string, Unicode karakterlerinden oluşan bir dizi gibi algılanabilir. C ve C++ gibi dillerde string işlemlerini yapabilmek için karakter dizileri tanımlanır ve bunlar string olarak işleme alınırlar. C#’ta ise bu karakter dizilerini tanımlamak yerine string adlı yeni bir tür kullanılır.</p><p><strong>Kaynaklar</strong></p><p>Sefer ALGAN — Her Yönüyle C#</p><ul><li><a href="http://net-informations.com/faq/general/valuetype-referencetype.htm">Difference between a Value Type and a Reference Type</a></li><li><a href="https://www.microsoftpressstore.com/articles/article.aspx?p=2454676">Understanding Values and References in Microsoft Visual C#</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=178d3a5823ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>