<?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 Agit Rubar Demir on Medium]]></title>
        <description><![CDATA[Stories by Agit Rubar Demir on Medium]]></description>
        <link>https://medium.com/@agitrubard?source=rss-63fe19de2b08------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IVAplVObnzOisd8-iaxthA.png</url>
            <title>Stories by Agit Rubar Demir on Medium</title>
            <link>https://medium.com/@agitrubard?source=rss-63fe19de2b08------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:32:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@agitrubard/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[Passkeys: Arka Planda Neler Oluyor?]]></title>
            <link>https://medium.com/@agitrubard/passkeys-arka-planda-neler-oluyor-4df1212a244c?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/4df1212a244c</guid>
            <category><![CDATA[passkey]]></category>
            <category><![CDATA[passwords]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[webauthn]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 11:19:39 GMT</pubDate>
            <atom:updated>2026-06-17T11:19:39.293Z</atom:updated>
            <content:encoded><![CDATA[<p>Bir önceki yazımda, hepimizin canını sıkan uzun vekarmaşık <strong>Şifremi Unuttum</strong> akışlarından, Passkeys teknolojisiyle hayatımıza giren Kilit-Anahtar mantığından bahsetmiştim. Artık karşı tarafa şifre göndermek yerine, sadece <strong>cihazımızın kilidini açarak saniyeler içinde</strong> giriş yapabiliyoruz.</p><p>Kullanıcı deneyimi açısından dışarıdan bakınca her şey kusursuz çalışıyor. Ama işin mutfağına girdiğimizde hepimizin aklına doğal olarak şu sorular geliyor:</p><p><strong>Peki bu sistem gerçekten anlatıldığı kadar güvenli mi? Arka plandaki şifreleme altyapısı nasıl çalışıyor? Uygulamaların veritabanları hacklenirse ne olur? Ve en önemlisi; telefonumu kaybedersem veya çaldırırsam bütün dijital hayatım da onunla beraber yok mu olacak?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GyR1MKLJ97yRJWAgTfyhfA.jpeg" /></figure><p>Dışarıdan çok basit görünen bu sürecin teknik detaylarına ve arka planda nasıl çalıştığına biraz daha yakından bakalım.</p><h3>Challenge ve Response Kavramları</h3><p>Teknik akışın tam kalbinde yer alan <strong>Challenge</strong> ve <strong>Response</strong> kavramlarını netleştirmekte fayda var. <strong>Challenge</strong>, sunucunun sadece o anki oturum açma denemesi için ürettiği tek kullanımlık, rastgele bir doğrulama verisidir. Bu yapının tek bir amacı vardır: Siber güvenlik dünyasında <strong>Replay Attack</strong> olarak bilinen o büyük zafiyeti kökünden çözmek.</p><p>Geleneksel parolaları, sisteme giriş yaparken her gün kullandığınız sabit bir veri dizisi gibi düşünebilirsiniz. Kötü niyetli biri bu veriyi ağ üzerinde yakalarsa, daha sonra sizin yerinize aynı veriyi kullanarak yetkisiz giriş yapabilir.</p><p>Passkeys mimarisinde ise süreç tamamen anlık bir döngüyle ilerler:</p><ul><li><strong>Challenge (Doğrulama İsteği):</strong> Sunucu, o anki oturuma özel, tamamen rastgele ve unique bir veri paketi üretip cihazınıza gönderir.</li><li><strong>Response (Dijital İmza):</strong> Cihazınızın güvenli donanımında saklanan Private Key, gelen bu unique veriyi kendi kriptografik algoritmasıyla işleyerek imzalar. Ortaya çıkan bu tek kullanımlık çıkış verisine <strong>Response</strong> denir. Aslında Response, Private Key’in kendisini internete asla çıkarmadan, o anahtara gerçekten sahip olduğunuzu sunucuya kanıtlayan anlık bir <strong>dijital imzadır</strong>.</li></ul><p>Saldırganlar o anki ağ trafiğini dinleyip gönderdiğiniz <strong>Response </strong>verisini havada kopyalasa bile bu hiçbir işlerine yaramaz. Çünkü bir sonraki giriş denemenizde sunucu bambaşka bir Challenge üretecektir; dolayısıyla dünkü eski Challenge ile üretilmiş kopya dijital imza, yeni oturumu kesinlikle açmayacaktır.</p><h3>İşin Temeli: Discoverable Credential, Public Key ve Private Key</h3><p>Passkeys, aslında yıllardır güvenliği kanıtlanmış olan <strong>Asymmetric Cryptography</strong> altyapısını kullanan bir <strong>Discoverable Credential</strong> (Keşfedilebilir Kimlik Bilgisi) çözümüdür. <strong>Discoverable</strong> olması şu anlama gelir: Sistemin sizi tanıması için artık bir kullanıcı adı veya e-posta girmenize bile gerek yoktur.</p><p>Bu teknoloji; iOS, Android ve Windows gibi tüm mobil ve masaüstü işletim sistemlerinde (ilgili native API’ler aracılığıyla) kusursuz şekilde çalışır. Ancak karmaşadan uzak durmak ve konuyu daha net bir çerçevede ele almak için, arka plandaki teknik akışı <strong>Web (WebAuthn JavaScript API)</strong> üzerinden anlatacağım. Kullanılan metodların adı platforma göre değişse de, arka plandaki iş mantığı her yerde tamamen aynıdır.</p><p>Operasyonel akış temel olarak iki ana aşamadan oluşur:</p><h4>1. Passkey İle Registration</h4><p>Bir platformda Passkey oluşturulurken;</p><ul><li>İstemci, sunucudan tek kullanımlık ve random bir <strong>Challenge</strong> talep eder.</li><li>Cihazınız WebAuthn API’sinin credentials.create(challenge) metodunu çağırır. Bu esnada güvenli donanımınız (Secure Enclave / TPM) unique bir anahtar çifti üretir.</li><li><strong>Private Key</strong>, cihazınızın güvenli donanımında <strong>dışa aktarılamaz (non-exportable) şekilde saklanır</strong>. Asla kopyalanamaz ve cihaz dışına çıkarılamaz.</li><li>Kayıt işleminin tamamlanması için <strong>Public Key</strong>, Challenge’ın imzalanmasıyla elde edilen <strong>Response</strong> ve unique bir <strong>Credential ID</strong>, internet üzerinden şifreli bir kanalla uygulamanın sunucusuna gönderilir. Sunucu bu verileri sizin kullanıcınızla eşleştirerek kaydeder.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*30TGS1U5tHPDALLLE2uK1g.png" /><figcaption>Created by Claude Design (Opus 4.8)</figcaption></figure><h4>2. Passkey İle Authentication</h4><p>Passkey’in mevcut olduğu bir platformda doğrulama yapılırken;</p><ul><li>İstemci, sunucudan o anki oturuma özel, yepyeni bir <strong>Challenge</strong> ister.</li><li>Cihazınız credentials.get(challenge) metodunu tetikler ve işlemi doğrulamak için sizden biyometrik onay (FaceID, TouchID vb.) ister.</li><li>Onay verdiğiniz anda cihazınız kendi <strong>Private Key</strong>’ini kullanarak, donanımının içinde bu unique veriyi kriptografik olarak işler ve bir <strong>Response</strong> oluşturur.</li><li>Cihazınız; üretilen bu <strong>Response</strong> verisini ve <strong>Credential ID</strong>’yi sunucuya iletir. Sunucu, elindeki <strong>Public Key</strong> ile bu dijital imzanın doğruluğunu teyit eder. Kriptografik Doğrulama başarılıysa oturum açılır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lLAAjuqggJ1b5td1Terk-A.png" /><figcaption>Created by Claude Design (Opus 4.8)</figcaption></figure><p>Bu süreçte şifreniz internette asla dolaşmaz, sadece tek kullanımlık <strong>Response</strong> verisi ağ üzerinde gidip gelir.</p><h3>Sunucu Hacklenirse veya Phishing Saldırılarında Ne Olur?</h3><p>Geleneksel sistemlerde bir platformun veritabanı hacklendiğinde, parolalarınızın (şifrelenmiş olsalar bile) çalınma veya kırılma riski her zaman vardı. Passkeys altyapısında ise sunucu tarafında yaşanan bir veri sızıntısında saldırganların eline geçebilecek tek şey <strong>Public Key</strong>’dir. Adı üzerinde zaten <strong>açık</strong> bir veri olan bu anahtar, cihazınızdaki Private Key tarafından oluşturulan anlık bir dijital imza olmadan tek başına hiçbir hesaba erişim sağlayamaz. Dolayısıyla veritabanı sızıntıları, Passkeys kullanıcıları için bir güvenlik tehdidi oluşturmaz.</p><p>Peki ya sahte siteler? Tasarımı birebir kopyalanmış sahte bir web sitesine yönlendirilip tuzağa düşürülürsek ne olur?</p><p>Passkeys mimarisinin en güçlü güvenlik katmanlarından biri <strong>Origin-Bound (Kaynağa Bağlı)</strong> çalışmasıdır. Bir Passkey, sadece oluşturulduğu gerçek alan adı ile iletişim kuracak şekilde kriptografik olarak mühürlenir. Kullanıcı sahte bir ekranda giriş yapmak isteyip dalgınlıkla biyometrik onay verse dahi, cihaz arka planda URL doğrulamasını yapar. Talep edilen alan adının orijinal siteyle eşleşmediğini fark ettiği an doğrulama işlemini tamamen reddeder. Bu mimari sayesinde, sistemin geleneksel oltalama taktikleriyle kandırılma ihtimali <strong>teknik olarak sıfırdır.</strong></p><h3>Fiziksel Risk Senaryosu: Cihaz Kaybolur veya Çalınırsa Ne Olacak?</h3><p>Passkeys mimarisinde Private Key, cihazınızın güvenli donanımında <strong>dışa aktarılamaz (non-exportable) şekilde saklandığı</strong> için, doğal olarak akla gelen ilk risk cihazın fiziksel güvenliği oluyor. Cihazımız kaybolduğunda dijital hayatımıza erişimimizi de tamamen kaybedecek miyiz?</p><p>Bu riski yönetmek için Apple, Google ve Microsoft gibi teknoloji devleri, bulut tabanlı harika bir yedekleme mimarisi sunuyor. Oluşturduğunuz Passkey’ler, <strong>End-to-End Encrypted (Uçtan Uca Şifreli)</strong> bir şekilde kendi ekosistemlerindeki bulut kasalarınızla (iCloud Keychain, Google Password Manager vb.) senkronize ediliyor.</p><ul><li><strong>Cihaz Kaybı Durumunda:</strong> Cihazınızı kaybettiğinizde veya yenilediğinizde dijital varlıklarınıza erişiminiz kesilmiyor. Yeni cihazınızda ana bulut hesabınıza giriş yapmanız yeterli; tüm Passkey verileriniz, yeni cihazınıza güvenli bir şekilde otomatik olarak geri yükleniyor.</li><li><strong>Cihazın Çalınması Durumunda:</strong> Cihazınız fiziksel olarak kötü niyetli kişilerin eline geçse bile Passkey’leriniz güvendedir. Bir Passkey’in işlem yapabilmesi için cihazın kilit ekranı parolasının bilinmesi veya <strong>biyometrik onay (FaceID, TouchID)</strong> verilmesi zorunludur. Cihazın donanımsal kilidi aşılamadığı sürece, içerideki anahtarlar kesinlikle kullanılamaz.</li></ul><h3>Farklı Cihazlar Arası Geçiş (Cross-Device)</h3><p>Passkeys mimarisi, sadece oluşturulduğu ekosisteme (örneğin sadece Apple cihazları arasına) hapsolmak zorunda değildir. Örneğin; şirketteki bir Windows bilgisayardan bir platforma giriş yapmak istiyorsunuz, ancak o platforma ait <strong>Passkey</strong> o an yalnızca cebinizdeki iPhone’da bulunuyor.</p><p><strong>FIDO standartları</strong> çerçevesinde oluşturulan <strong>cross-device desteği</strong> sayesinde bilgisayar ekranında beliren <strong>QR Code</strong>’u<strong> </strong>telefonunuzun kamerasına okutarak işlemi kolayca başlatabilirsiniz. Bu esnada iki cihaz arasında <strong>Bluetooth yakınlık doğrulaması</strong> <strong>(proximity check)</strong> yapılır ve bilgisayardaki oturum, telefonunuzun donanımında bulunan <strong>Private Key</strong> aracılığıyla güvenli bir şekilde açılır.</p><p>Özetlemek gerekirse Passkeys; <strong>donanım destekli altyapı</strong>sı, <strong>dijital imza</strong>lara dayanan arka planı ve <strong>phishing saldırılarına karşı güvenli</strong> olması ile birlikte kullanıcılara çok güçlü bir güvenlik mimarisi sunuyor.</p><p>Peki, güvenlik ve pratiklik bu kadar yüksekse neden hala dijital hayatımızın her noktasında bu teknolojiyi kullanamıyoruz? Sektörün adaptasyon sürecinde karşılaştığı temel teknik bariyerler neler? Tüm bu soruların cevabını ve parolasız geleceğin yol haritasını, serinin son yazısı olan <strong>Bölüm 3: Parolasız Hayat 2.0 ve Gelecek Vizyonu </strong>başlığında detaylıca inceleyeceğim.</p><blockquote>Bu yazı, dijital kimlik doğrulamanın dönüşümünü incelediğim yazı serisinin ikinci bölümüdür. Problemin kaynağını ve Passkeys teknolojisinin temel mantığını anlattığım serinin ilk yazısını okumadıysanız, öncelikle <a href="https://medium.com/@agitrubard/passkeys-nedir-passwordless-life-e6ae061500f3">Passwordless Life 1.0: Parolaların Sonu mu Geldi?</a> başlıklı yazıma göz atmanızı öneririm.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4df1212a244c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Passwordless Life 1.0: Parolaların Sonu Mu Geldi?]]></title>
            <link>https://medium.com/@agitrubard/passkeys-nedir-passwordless-life-e6ae061500f3?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6ae061500f3</guid>
            <category><![CDATA[passkey]]></category>
            <category><![CDATA[passwordless]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 10:21:01 GMT</pubDate>
            <atom:updated>2026-03-31T19:43:57.997Z</atom:updated>
            <content:encoded><![CDATA[<p>Hepimiz günlük hayatta kullandığımız platformlarda veya yeni bir uygulamaya kayıt olurken <strong>“Şifreniz en az bir büyük harf, bir rakam ve bir özel karakter içermelidir.”</strong>, <strong>“Şifrenizin süresi dolmuştur. Lütfen eski şifrenizden farklı, ardışık olmayan 6 haneli yeni bir şifre belirleyin.”</strong> gibi cümleler ile mutlaka karşılaşmışızdır.</p><p>İnsanlık tarihi boyunca değer verdiğimiz şeyleri korumak için çok basit ve etkili bir mekanizma kullandık: Kilitler ve anahtarlar. Fiziksel dünyada evimizi veya kasamızı koruyan bu yapı, internetle tanıştığımızda dijitalleşti ve karşımıza <strong>“parolalar”</strong> olarak çıktı.</p><p>Başlangıçta süreç çok basitti; tek bir e-posta adresimiz, tek bir forum üyeliğimiz ve aklımızda tuttuğumuz tek bir parolamız vardı. Ancak dijital hayatımız genişledikçe bir problemin içine hapsolmaya başladık: Kullandığımız platformların sayısı arttıkça, yönetmemiz gereken parolaların sayısı hafızamızın sınırlarını aştı.</p><h3>Aynı Parola İle Tüm Platformlara Erişme Yanılgısı</h3><p>Kullanmamız gereken platform sayısı onlarcadan yüzlere çıkınca, pratik bir çözüm bulduk: Aynı parolayı her platform için kullanmak. Ancak bu durum büyük bir güvenlik krizini beraberinde getirdi. Herhangi bir platform hacklendiğinde veya bir oltalama (phishing) tuzağına düştüğümüzde, kopyalanan o tek parola tüm dijital hayatımızı savunmasız bıraktı.</p><p>Buna karşılık sistemlerin geliştirdiği savunma mekanizması ise parola oluşturma koşullarını zorlaştırmak oldu. Karşımıza çıkan o meşhur kuralları hepimiz biliyoruz: <strong><em>“Şifreniz en az bir büyük harf, bir rakam ve ardışık olmayan karakterler içermelidir.”</em></strong> Artık parola oluşturmak bizim için zorlaşmıştı. Hafızamıza güvenemediğimiz için bu operasyonel yükü <strong>Parola Yöneticilerine (Password Managers)</strong> devrettik. Bu uygulamalar bizim yerimize kırılması zor, <strong>rastgele (random) şifreler</strong> üretiyor. Artık elimizde yüzlerce anahtarın olduğu devasa bir dijital anahtarlık var ve biz sadece o parola yöneticisinin erişim parolasını ezberleyebiliyoruz.</p><p>Ancak temeldeki mimari kusur hala devam etmekte: Parola ne kadar karmaşık olursa olsun, giriş yapabilmek için o şifreyi internet üzerinden karşıdaki sunucuya göndermek zorundayız. Ve internet üzerinden gönderilen her bilgi, yolculuk esnasında veya sunucuda çalınma riski taşıyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bM3K3HKUSvAS2bqWh3gy9w.jpeg" /></figure><h3>Kırılmaz Bir Anahtar: Passkeys Teknolojisi ve Standartlar</h3><p><strong>Passkeys (Geçiş Anahtarları)</strong>, dijital güvenliği baştan aşağı değiştiriyor. FIDO Alliance çatısı altında birleşen <strong>Apple</strong>, <strong>Google</strong>, <strong>Microsoft</strong>, <strong>WebAuthn standartları</strong>yla “internet üzerinden şifre gönderme” dönemini kapatıyor. Geleneksel sistemde şifreler internette dolaşır ve sunucularda saklanır; bu da çalınma riski demek. Passkeys ile bu risk ortadan kalkıyor.</p><p>Artık kayıt olurken cihazınız (telefon veya bilgisayar) birbirini tamamlayan <strong>iki dijital parça</strong> üretir:</p><ol><li><strong>Kilit (Sunucuya Gider):</strong> Uygulama sunucusuna bırakılan bu parça çalınsa bile kimseye fayda sağlamaz.</li><li><strong>Anahtar (Cihazda Kalır):</strong> Cihazınızın güvenli donanımında saklanır ve asla dışarı çıkmaz.</li></ol><p>Doğrulama işlemi gerçekleşirken, tıpkı telefon kilidini açar gibi cihazınızın desteklediği <strong>biyometrik verinizi (FaceID, TouchID)</strong> veya PIN gibi yöntemler kullanırsınız. Cihaz arka planda kendi anahtarını sunucudaki kilit ile matematiksel olarak saniyeler içinde eşleştirir ve onayı verir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sp8UW6kMcQRG0vt6_kntFQ.jpeg" /><figcaption><em>Created by Nano Banana 2 (Gemini 3 Flash Image)</em></figcaption></figure><p>Özetle, sahte siteler sizi kandıramaz çünkü internette şifre dolaşmaz. Sunucu hacklense bile çalınacak bir parola yoktur.</p><h3>Peki Her Şey Çözüldü mü? Neden 1.0?</h3><p>Passkeys, şifrelerin yarattığı güvenlik açıklarını ve kullanıcı tarafındaki operasyonel zorlukları çözen çok önemli bir teknoloji. Bize nihayet hedeflediğimiz parolasız (<strong>passwordless)</strong> hayatı sunuyor.</p><p>Ancak bu büyük dönüşümün henüz adaptasyon aşamasındayız. Tam da bu yüzden, içinde bulunduğumuz bu geçiş dönemini <strong>Passwordless Life 1.0 </strong>olarak adlandırıyorum.</p><p>Konu, tek bir yazıya sığdırılamayacak kadar kapsamlı ve dijital alışkanlıklarımızı kökten değiştirecek bir potansiyele sahip. Bu nedenle süreci bir<strong> yazı serisi </strong>olarak planladım. İlk yazımda <strong>parolaların hayatımızdaki zorlukları</strong>na<strong> </strong>ve <strong>Passkeys’in temel mantığı</strong>na değindim. Serinin devamında;</p><ul><li><strong>Passkeys: Arka Planda Neler Oluyor?</strong> Bu sistem teknik olarak nasıl çalışıyor? Kriptografik altyapısı nasıl kurgulandı? Sistem hacklenebilir mi, cihazımız kaybolursa ne olur; kısacası <strong>Passkeys gerçekten yeterince güvenli mi?</strong></li><li><strong>Passwordless Life 2.0: Gelecekte Bizi Neler Bekliyor? </strong>Hayatımızın her noktasında bu teknolojiyi kullanabilecek miyiz? Sadece hesaplarımıza ilk girişte değil; <strong>ödeme yaparken, para transferlerini onaylarken veya kurumsal ağlara bağlanırken</strong> bu standart nasıl çalışacak? Farklı ekosistemler ve cihazlar arası geçişlerde (cross-device authentication) bizi hangi limitasyonlar bekliyor ve neden henüz tam anlamıyla 2.0 seviyesinde değiliz?</li></ul><p>Tüm bu soruların cevaplarını ve Passkeys mimarisinin teknik detaylarını <strong>bir sonraki yazımda</strong> aktarmaya çalışacağım. Görüşmek üzere!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6ae061500f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Program to Interface, Not an Implementation: Peki Neden?]]></title>
            <link>https://medium.com/@agitrubard/program-to-interface-not-an-implementation-peki-neden-6073c1b46c1b?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/6073c1b46c1b</guid>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Wed, 17 Dec 2025 07:46:50 GMT</pubDate>
            <atom:updated>2025-12-17T07:46:50.080Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu cümleyi bir yerde görmüş olabilirsiniz:</p><blockquote>Program to Interface, Not an Implementation</blockquote><p>Ama <strong>interface</strong> ve <strong>implementation</strong> kelimelerini ilk defa duyuyorsanız, cümle doğal olarak havada kalabilir. Bu yüzden önce en basit haliyle iki kavramı netleştirmek iyi olur.</p><h4>Interface ne ifade eder?</h4><p>Interface, en basit haliyle <strong>ne yapılabileceğini</strong> tarif eder.</p><ul><li>Ödeme alınabilir.</li><li>Bildirim gönderilebilir.</li><li>Dosya saklanabilir.</li></ul><p>Yani interface, <strong>hangi davranışın beklendiğini</strong> anlatır. Java gibi dillerde bu çoğu zaman bir interface dosyasıyla temsil edilir. Ama asıl fikir, <strong>davranışı isimlendirmek</strong> ve <strong>kullanım şeklini sabitlemektir</strong>.</p><h4>Implementation ne ifade eder?</h4><p>Implementation ise <strong>nasıl yapıldığını</strong> anlatır.</p><ul><li>Ödeme hangi sağlayıcıyla alınır?</li><li>Bildirim SMS mi e-posta mı olur?</li><li>Dosya nerede tutulur?</li></ul><p>Yani implementation, detayları taşır: <strong>kullanılan kütüphane, SDK, protokol, veri modeli, hata yönetimi</strong> gibi.</p><p>Bu ikisini tek cümleye indirgersek:</p><ul><li><strong>Interface → ne</strong></li><li><strong>Implementation → nasıl</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HvxX7jxdxoBdBORFcjpmDw.jpeg" /></figure><p>Bu cümle <strong>rastgele üretilmiş bir slogan gibi değildir</strong>; 90’ların ortasında yayımlanan <em>Design Patterns (GoF)</em> kitabının ortaya koyduğu tasarım bakış açısıyla birlikte yaygınlaşmış bir prensip olarak görülebilir. O dönemde de bugün de benzer bir sorun görülebilir: Sistem büyüdükçe bazı parçalar kaçınılmaz şekilde değişebilir ve kod doğrudan <strong>nasıl yapıldığına</strong>(somut sınıflara, kütüphane/entegrasyon detaylarına) bağlandığında, <strong>küçük bir değişiklik bile zincirleme biçimde birçok noktaya yayılabilir</strong>.</p><p>Bu yüzden şu fikir korunur:</p><blockquote><strong>Kodun büyük kısmı, değişken implementasyon detaylarına değil; daha stabil kalabilecek bir davranış tanımına (interface/contract) bağlanmalıdır.</strong></blockquote><h3>Program to Interface tam olarak ne demek istiyor?</h3><p>Bu yaklaşım genelde <strong>her yere interface yazın</strong> gibi okunmaz. Ama projeyi uzun vadeli düşündüğünüzde, daha doğru okursak şöyle düşünebiliriz:</p><p><strong>Kod, bir sınıfın kendisine değil; o sınıfın temsil ettiği davranışa bağlanmalıdır.</strong></p><p>Burada asıl amaç <strong>interface dosyası üretmek değildir</strong>; <strong>bağımlılıkların nereye bağlanacağını belirlemektir</strong>. Çünkü bir projede bağımlılıkların hedefi somut sınıflar olduğunda, kod zamanla <strong>bir uygulama olmaktan çıkar</strong>, o sınıfların etrafında şekillenen bir yapıya dönüşür.</p><p>Bu yüzden <strong>hangi sınıf</strong> sorusu ikinci plana düşer, <strong>hangi davranış</strong> sorusu öne çıkar. Pratikte şu şekilde görülür:</p><p>Bir servis <strong>A client’ını kullanıyor</strong> diye tanımlanmak yerine, <strong>ödeme alınması</strong> gibi bir davranışa bağlanır.</p><p>Böylece servis, bir kütüphaneyi değil; <strong>bir davranışı tüketiyor</strong> gibi konumlanır.</p><h3>Not an Implementation kısmı neden kritik?</h3><p>Çünkü implementasyon tarafı genelde daha hızlı değişebilir.</p><ul><li>Provider (sağlayıcı) değişebilir.</li><li>Protokol güncellenebilir.</li><li>Güvenlik kısıtları zorunlu hale gelebilir.</li></ul><p>Bu değişiklikler kaçınılmaz olabilir. Buradaki kritik soru şu hale gelir:</p><p><strong>Bu değişiklikler domain’e kadar taşınmak zorunda mı kalır, yoksa sınırlandırılabilir mi?</strong></p><p>Kod doğrudan implementasyona bağlandığında değişim birçok yere yayılabilir. Kod bir interface üzerinden şekillendiğinde ise değişim daha dar bir alanda tutulabilir.</p><p>Bu yüzden <strong>not an implementation</strong> kısmı, tasarımda bir tercih değil; <strong>sürdürülebilirlik için bir sınır çizme biçimi</strong> haline gelir.</p><h3>Peki bunu nasıl örneklendirebiliriz?</h3><p>Domain’in <strong>ödeme alma</strong> ihtiyacı olduğu düşünülebilir. Bu davranış bir interface üzerinden ifade edilir:</p><pre>public interface PaymentGateway {<br>  void pay(PaymentRequest request);<br>}</pre><p>Burada <strong>ödeme alınabilir</strong> davranışı tanımlanır. Nasıl alındığı, yani sağlayıcıya özel detaylar, başka bir implementasyonda tutulur:</p><pre>class PaymentGatewayFirstImpl implements PaymentGateway {<br><br>  @Override<br>  public void pay(PaymentRequest request) {<br>    // implementation details<br>  }<br><br>}</pre><pre>class PaymentGatewaySecondImpl implements PaymentGateway {<br><br>  @Override<br>  public void pay(PaymentRequest request) {<br>    // implementation details<br>  }<br><br>}</pre><p>Bu ayrım sayesinde domain tarafı şunu yapar:</p><ul><li><strong>Ödeme alınabilir</strong> davranışını kullanır.</li><li><strong>Hangi sağlayıcı ile alındığı</strong> bilgisine ihtiyaç duymaz.</li><li><strong>Implementasyon detaylarını</strong> taşımak zorunda kalmaz.</li></ul><p>Bu yaklaşım, domain’in <strong>iş dilinde kalmasını</strong> mümkün kılabilir.</p><h3>Bu yaklaşımın ana kazancı ne olabilir?</h3><p>Bu yaklaşım benimsendiğinde bir projede şu etkiler görülebilir:</p><ul><li>Kodun <strong>ne yaptığı</strong> daha net okunabilir hale gelebilir.</li><li>Değişmesi muhtemel detaylar tek bir tarafta toplanabilir.</li><li>Test yazımı daha doğal bir hale gelebilir; fake implementasyonlar kullanılabilir.</li><li>Domain, <strong>detay taşıyan</strong> bir katmana dönüşmek zorunda kalmayabilir.</li></ul><p>Ama burada asıl kritik kazanç daha temel bir yere bağlanır:</p><p><strong>Bağımlılıklar yönetilebilir hale gelebilir.</strong></p><p>Çünkü dependency yönetimi yapılmadığında proje şu şekilde ilerleyebilir: bugün <strong>hızlı çözüm</strong> gibi görünen bir kullanım, yarın <strong>her yere yayılan değişim</strong>e dönüşebilir.</p><p>Interface kullanımı, bu yayılmayı sınırlayabilecek bir yapı sunar.</p><h3>Peki herkes interface yazmalı mı?</h3><p>Bu soruya klasik cevap <strong>hayır</strong> olabilir. Çünkü bazı örneklerde interface gerçekten değer üretmeyebilir gibi görünebilir. Ama pratikte, özellikle sürdürülebilirlik odağıyla baktığınızda, soru şu şekilde değişir:</p><p><strong>Bir projede bağımlılıkları uzun vadede yönetmek istiyorsanız, interface neredeyse her zaman gerekli hale gelebilir.</strong></p><p>Çünkü interface, sadece bir soyutlama değildir; aynı zamanda bir <strong>bağımlılık kontrol noktasıdır</strong>.</p><p>Bir ekip <strong>interface yazmama</strong> refleksiyle ilerlediğinde şunlar yaşanabilir:</p><ul><li>Servisler somut sınıflara bağlanabilir.</li><li>Domain dili yavaş yavaş implementasyon diliyle karışabilir.</li><li>Değişiklik maliyeti kontrolsüz büyüyebilir.</li></ul><p>Buna karşılık interface, bağımlılıkları <strong>davranış düzeyinde</strong> tanımladığı için, projenin büyümesiyle birlikte şu avantajları koruyabilir:</p><ul><li>bağımlılık yönü domain’den dışarı doğru kurulabilir</li><li>dış detaylar domain’in içine taşınmayabilir</li><li>değişiklik geldiğinde etki alanı sınırlı kalabilir</li><li>proje büyüdükçe sistem dağılmak yerine daha düzenli kalabilir</li></ul><p>Bu yüzden mesele <strong>interface var mı</strong> sorusu olmayabilir. Daha doğru soru şu olabilir:</p><p><strong>Bağımlılıkları kontrol edebilecek bir sınır var mı?</strong></p><p>Interface, çoğu zaman bu sınırı sağlayabilecek en net araç haline gelebilir.</p><h3>Interface her yerde nasıl anlam kazanabilir?</h3><p>Burada <strong>her yere interface yazmak</strong> ile <strong>her bağımlılığı interface üzerinden yönetmek</strong> farklı şeylerdir.</p><p>Her sınıfa interface açmak zorunda kalınmaz. Ama her bağımlılık ilişkisi, bir <strong>davranış sözleşmesi</strong> üzerinden kurgulanabilir.</p><p>Yani amaç, XServiceImpl üretmek değildir. Amaç, şunu mümkün kılmaktır: <strong>Domain’in bağımlılığı, implementasyona değil; kendi tanımladığı davranışa bağlanır.</strong></p><p>Bu yaklaşım oturduğunda <strong>interface gereksiz mi</strong> sorusu zamanla şuna dönüşür: <strong>Bağımlılığı hangi noktadan yönetmek daha sürdürülebilir olur?</strong></p><p>Ve çoğu projede cevap şu tarafa yaklaşır: <strong>Bağımlılık, interface üzerinden yönetilir.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6073c1b46c1b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cherry Pick: İhtiyaç Olduğunu Bilmiyordunuz Ama Kesinlikle Öyle!]]></title>
            <link>https://medium.com/@agitrubard/cherry-pick-ihtiyaciniz-oldugunu-bilmiyordunuz-ama-kesinlikle-oyle-617453c8ca80?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/617453c8ca80</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[cherrypick]]></category>
            <category><![CDATA[version-control]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Wed, 21 May 2025 07:31:40 GMT</pubDate>
            <atom:updated>2025-05-21T07:31:40.417Z</atom:updated>
            <content:encoded><![CDATA[<p>Yazılım geliştirme süreçlerinde bazen sadece belirli bir değişikliği bir branch’ten diğerine taşımanız gerekir. Peki bu durumda ne yaparsınız? Çoğu geliştirici ya tüm branch’i merge eder ya da manuel olarak dosya taşıma gibi hataya açık yöntemlere başvurur. Ancak Git dünyasında bunun için çok daha etkili bir çözüm var: <strong>Cherry Pick</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NzhkKVK7beL7XXPG7Te6vw.jpeg" /></figure><h3><strong>Cherry Pick Nedir ve Sanılanın Aksine Ne Yapar?</strong></h3><p>Cherry Pick, Git’te bir branch’teki belirli bir commit’i alıp başka bir branch’e taşımanıza olanak tanır. Ancak burada kritik bir detay vardır: Cherry Pick, <strong>mevcut commit’i olduğu gibi kopyalamaz</strong>. Onun <strong>içeriğini alır</strong> ve <strong>hedef branch’te yeni bir commit oluşturur</strong>. Bu işlem, taşınan değişikliklerin hedef branch’e uyumlu ve bağımsız bir şekilde entegre edilmesini sağlar. Orijinal commit, kaynağında hiçbir değişikliğe uğramadan olduğu gibi korunur.</p><ul><li><strong>Orijinal commit olduğu gibi kalır:</strong> Bu, orijinal commit’in bozulmadan korumanızı sağlar.</li><li><strong>Yeni bir commit oluşturulur:</strong> Hedef branch’e taşınan değişiklikler, yeni bir commit numarasıyla, mevcut kod tabanına uygun bir şekilde eklenir.</li><li><strong>Sadece ihtiyaç duyulan değişiklikler entegre edilir:</strong> Gereksiz değişiklikleri taşımadan, kodun tutarlılığını koruyarak iş akışınızı düzenler.</li></ul><p>Cherry Pick, karmaşık projelerde <strong>düzeni sağlamak</strong> ve yalnızca <strong>ihtiyaç duyulan değişiklikleri taşımak</strong> için kritik bir özelliktir. Özellikle bir branch’in tamamını merge etmek istemediğiniz durumlarda ya da belirli bir değişikliği hızlıca farklı bir branch’e taşımak gerektiğinde devreye girer. Bu yöntem, projelerde gereksiz karmaşıklığı önler ve iş akışlarınızda düzenli bir süreç sağlar. Cherry Pick’i doğru bir şekilde iş akışınıza entegre ettiğinizde, kod yönetim süreçlerinizdeki karmaşıklığı azaltabilir, projelerinize <strong>esneklik</strong> ve <strong>kalite</strong> kazandırabilirsiniz.</p><h3><strong>Cherry Pick Neden Kullanılır?</strong></h3><h4><strong>1. Hotfix Senaryoları</strong></h4><p>Development ortamında kritik bir hata fark ettiniz ve bu hatayı test branch’inizde düzelttiniz. Ancak, test branch’i hâlâ tamamlanmamış geliştirmeler içeriyor. Tüm branch’i merge etmek yerine yalnızca bu hata düzeltmesini dev branch’ine taşımak istiyorsunuz. Cherry Pick tam bu noktada devreye girer.</p><h4><strong>2. Seçici Taşıma</strong></h4><p>Geliştirme branch’inde yaptığınız bir değişikliği, başka bir branch’te de kullanmak istiyorsunuz. Örneğin, belirli bir özelliği yalnızca bir müşteri için aktif hale getirmek gerektiğinde Cherry Pick ideal bir özelliktir.</p><h4><strong>3. Yanlış Branch Üzerinde Çalışma</strong></h4><p>Yanlış branch üzerinde çalışmaya başladığınız commit’i doğru branch’e taşımak istiyorsunuz. Cherry Pick bu durumda hem kolaylık sağlar hem de düzeni korur.</p><h4><strong>4. Dağıtılmış Ekipler</strong></h4><p>Farklı ekiplerin aynı kod tabanı üzerinde çalıştığı durumlarda, belirli bir değişikliği yalnızca ihtiyaç duyan branch’e taşıyarak ekiplerin bağımsız bir şekilde ilerlemesini sağlayabilirsiniz.</p><h3><strong>Cherry Pick Kullanırken Dikkat Edilmesi Gerekenler</strong></h3><p>Cherry Pick, doğru kullanıldığında büyük kolaylık sağlarken, yanlış kullanımı karmaşıklığa neden olabilir.</p><h4><strong>1. İlgisiz Commit’leri Taşımayın</strong></h4><p>Cherry Pick yalnızca <strong>gerçekten ihtiyaç duyduğunuz değişiklikler için</strong> kullanılmalı. <strong>Her commit’i taşımaya çalışmak</strong>, kod tabanınızda <strong>gereksiz </strong>karmaşıklığa yol açabilir.</p><h4><strong>2. Commit Mesajlarına Dikkat Edin</strong></h4><p>Eski commit’teki commit mesajını alarak yeni bir commit oluşturulduğu için, atılan bütün <strong>commit mesajlarını anlamlı tutmak</strong> önemlidir. Bu, taşınan değişikliklerin hangi bağlamda yapıldığını <strong>anlamayı kolaylaştırır</strong>.</p><h4><strong>3. Merge Conflict’lere Karşı Hazırlıklı Olun</strong></h4><p>Cherry Pick sırasında <strong>conflict</strong> meydana gelebilir. Özellikle aynı dosyada yapılan diğer değişikliklerle <strong>conflictler yaşanabilir</strong>. Bu durumda, <strong>conflictleri</strong> dikkatlice <strong>çözmek</strong> ve <strong>kodun</strong> <strong>bağlamını</strong> <strong>anlamak</strong> kritik önem taşır.</p><h4><strong>4. Sık ve Gereksiz Kullanımdan Kaçının</strong></h4><p>Cherry Pick, planlama eksikliği nedeniyle <strong>çok sık kullanılıyorsa</strong>, bu bir <strong>süreç sorunu</strong>na işaret edebilir. Bu özelliği <strong>yalnızca gerektiğinde</strong> ve <strong>belirli bir amaç doğrultusunda kullanma</strong>ya özen gösterin.</p><h4><strong>5. Kodun Tutarlılığını Kontrol Edin</strong></h4><p>Cherry Pick ile <strong>taşınan değişikliklerin hedef branch’in mantığıyla uyumlu </strong>olduğundan emin olun. <strong>Uyumsuz değişiklikler</strong>, ileride <strong>teknik borç </strong>yaratabilir.</p><h3><strong>Cherry Pick İş Akışlarına Nasıl Daha Verimli Entegre Edilir?</strong></h3><p>Cherry Pick, projelerde <strong>karmaşıklığı azaltan</strong> ve <strong>seçiciliği artıran</strong> bir özelliktir. Ancak bu özelliği daha <strong>verimli kullanmak için</strong> iş akışlarınızda <strong>doğru stratejileri belirlemeniz</strong> gerekir.</p><h4><strong>Esneklik Sağlar</strong></h4><p>Cherry Pick, <strong>yalnızca kriz anlarında değil</strong>, <strong>düzenli iş akışlarında</strong> da kullanılabilir. Özellikle <strong>farklı branch’ler arasında</strong> seçici <strong>değişiklik taşımak gerektiğinde</strong> esneklik sağlar.</p><h4><strong>İşbirliğini Destekler</strong></h4><p><strong>Farklı ekiplerin</strong> aynı kod tabanında <strong>çalıştığı projelerde</strong>, <strong>Cherry Pick kullanımı</strong> ekipler arasında daha <strong>güçlü bir işbirliği</strong> sağlar. Seçici değişikliklerle ekipler bağımsız bir şekilde ilerleyebilir.</p><h4><strong>Bağlamı Korur</strong></h4><p><strong>Taşınan commit</strong>’lerin <strong>hedef branch’te yeni bir commit</strong> olarak oluşturulması, orijinal kodun <strong>bağlamını korur</strong>ken, <strong>taşınan değişiklikler</strong>in yeni branch’e <strong>uyumlu</strong> bir şekilde <strong>entegre edilmesi</strong>ni sağlar. Bu da kodun gelecekteki sürdürülebilirliğini artırır.</p><p><strong>Daha verimli bir Cherry Pick</strong> süreci için <strong>squash and merge</strong> yöntemini de iş akışınıza dahil etmeyi düşünebilirsiniz. Bu yöntem, birden fazla commit’i tek bir commit altında birleştirerek geçmişinizi daha temiz ve okunabilir hale getirir. Squash and Merge ile Cherry Pick’i birleştirerek commit geçmişini kontrol altında tutabilir, hem iş birliğini artırabilir hem de kod tabanında daha az karmaşıklık yaratabilirsiniz.</p><p>Squash and Merge yönteminin avantajlarını öğrenmek ve Cherry Pick ile nasıl sinerji oluşturabileceğinizi görmek için <a href="#">Squash and Merge Kullanımı ve Avantajları</a> makaleme göz atabilirsiniz. Doğru kombinasyonlarla iş akışlarınızı bir üst seviyeye taşımak elinizde!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=617453c8ca80" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Global Bir Uygulama Tasarlarken Yapılabilecek En Kritik Hata: Timezone Karmaşası]]></title>
            <link>https://medium.com/@agitrubard/global-bir-uygulama-tasarlarken-yapilabilecek-en-kritik-hata-timezone-karmasikligi-15634fe5c0bf?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/15634fe5c0bf</guid>
            <category><![CDATA[timezone-difference]]></category>
            <category><![CDATA[globalization]]></category>
            <category><![CDATA[timezone]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Wed, 16 Apr 2025 07:31:24 GMT</pubDate>
            <atom:updated>2025-04-16T07:31:24.137Z</atom:updated>
            <content:encoded><![CDATA[<p>Yazılım geliştirirken sıkça karşılaşılan ancak yeterince önem verilmeyen konulardan biri timezone (zaman dilimi) problemleridir. Özellikle küresel ölçekte çalışan uygulamalarda, timezone yönetimi hatalı yapılırsa kullanıcı deneyimi ve veri tutarlılığı açısından ciddi sorunlar ortaya çıkabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bwAzzjDzohpih0PTCrPqLw.jpeg" /></figure><h3>Timezone Problemleri Nedir, Neden Ortaya Çıkar?</h3><p>Timezone problemleri, uygulamanızın farklı coğrafi bölgelerde kullanılmaya başlamasıyla birlikte ortaya çıkar.</p><p>Bu sorunlar genellikle aşağıdaki nedenlerden kaynaklanır:</p><h4>Sunucu seviyesinde farklı timezone’ların kullanılması</h4><p>Her bir sunucunun farklı timezone’larda çalışması durumunda, uygulamanızdaki tarih ve saat verilerinde tutarsızlıklar oluşabilir.</p><h4>Veritabanı seviyesinde farklı timezone’ların kullanılması</h4><p>Veritabanı sunucusunun timezone’u farklı olduğunda, veri girişi ve okumasında karmaşık durumlar ortaya çıkar.</p><h4>Entegrasyonlar arası timezone uyuşmazlıkları</h4><p>Sisteminize farklı zaman dilimlerinden zaman damgalı veriler gönderildiğinde, eğer bunlar doğru şekilde işlenmezse entegrasyonlarda hata ve veri tutarsızlığı ortaya çıkar.</p><p>Örneğin, Türkiye’de sunucunuzun timezone’u GMT+3 iken veritabanı sunucunuz GMT+2&#39;de çalışıyorsa, veri girişleri sırasında bir saatlik sapma oluşacaktır. Ayrıca, API çağrıları sırasında gönderilen timestamp bilgilerinin farklı timezone’larda olması durumunda, entegrasyon süreçlerinde karmaşıklık ve hata oluşabilir.</p><h3>Timezone Problemleri İçin Doğru Çözüm Nedir?</h3><p>Timezone problemlerini çözmek için uygulanması gereken en iyi yöntem, <strong>sistem genelinde UTC (Coordinated Universal Time) kullanımını standartlaştırmaktır</strong>. Bu yaklaşım sayesinde bütün sistemleriniz tutarlı ve merkezi bir zaman dilimine göre çalışarak karışıklığın önüne geçer.</p><p>Aşağıdaki adımları takip ederek UTC temelli sistem tasarımını uygulayabilirsiniz:</p><h4>Sunucu ve Veritabanı Seviyesinde UTC Kullanımı</h4><ul><li>Tüm sunucularınızın saat dilimini UTC olarak ayarlayın.</li><li>Veritabanlarınızın saat dilimini UTC olarak ayarlayın ve tarih/saat alanlarını UTC’ye göre tutun.</li></ul><h4>Uygulama Seviyesinde Tarih ve Saat Bilgilerinin Yönetimi</h4><ul><li>Uygulama içinde tüm tarih ve saat işlemlerini UTC’ye göre gerçekleştirin.</li><li>Kullanıcılara gösterim yaparken, kullanıcının cihazından veya tarayıcısından timezone bilgisini alın ve sadece gösterim için kullanıcının yerel zamanına çevirin.</li></ul><h4>Entegrasyonlarda Tutarlılığı Sağlama</h4><ul><li>Sistemler arası entegrasyonlarda zaman damgalı verilerin timezone bilgisini net bir şekilde belirtin ve daima UTC kullanın.</li><li>API çağrılarında timestamp değerlerini ISO 8601 formatında UTC olarak gönderin ve alın. Böylece sistemler arası etkileşimde yaşanabilecek problemleri ortadan kaldırırsınız.</li></ul><h4>Örnek Senaryo</h4><p>Bir e-ticaret sitesinde siparişlerin takibini yapan küresel bir uygulamada:</p><ul><li>Kullanıcı Amerika’dan (GMT-5) sipariş verirken, sipariş bilgisi sunucuya UTC olarak kaydedilir.</li><li>Uygulama içindeki sipariş bilgileri ve işlemler tüm backend servislerinde UTC ile yönetilir.</li><li>Kullanıcı sipariş durumunu kontrol ettiğinde, uygulama UTC verisini alarak kullanıcının tarayıcısından aldığı timezone bilgisiyle sipariş saatini kullanıcının yerel saati ile gösterir.</li></ul><p>Bu yöntem sayesinde uygulama genelinde zaman dilimi tutarlılığı sağlanır ve küresel ölçekte doğru kullanıcı deneyimi sunulur.</p><h3>Avantajlar</h3><h4>Tutarlılık</h4><p>Sistem içindeki tüm tarih/saat verileri tutarlı olur.</p><h4>Hataların Azalması</h4><p>Tarih ve saatle ilgili oluşan hatalar minimuma iner.</p><h4>Kolay Yönetilebilirlik</h4><p>Sistemin genelinde tek bir zaman dilimi yönetimi, bakım ve yönetim süreçlerini kolaylaştırır.</p><p>Sonuç olarak, sistem genelinde UTC tabanlı bir yaklaşım kullanarak timezone problemlerinin önüne geçebilir, entegrasyonları sorunsuz hale getirebilir ve küresel ölçekte uygulamalar geliştirebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15634fe5c0bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Neden Squash and Merge?]]></title>
            <link>https://medium.com/@agitrubard/neden-squash-and-merge-41aa5b93992c?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/41aa5b93992c</guid>
            <category><![CDATA[squash-and-merge]]></category>
            <category><![CDATA[version-control-system]]></category>
            <category><![CDATA[merge-strategies]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Wed, 15 Jan 2025 10:32:20 GMT</pubDate>
            <atom:updated>2025-01-15T10:32:20.164Z</atom:updated>
            <content:encoded><![CDATA[<p>Squash and Merge, birden fazla commit’i tek bir commit olarak birleştirme imkanı sunan, hem <strong>commit geçmişini sadeleştiren</strong> hem de projeyi daha yönetilebilir hale getiren bir <strong>özellik</strong>. Özellikle büyük ekiplerde ve uzun soluklu projelerde, karmaşık commit geçmişleri ile uğraşmak yerine daha düzenli bir yapı sağlamak için bu yöntem tercih edilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HXP_2bMalz2Rr10jDyjUBQ.jpeg" /></figure><h3><strong>Peki, Neden Squash and Merge?</strong></h3><h4><strong>Daha Düzenli Bir Commit Geçmişi</strong></h4><p>Bir feature branch üzerinde geliştirme yaptığınızda, onlarca küçük commit atabilirsiniz. Örneğin, “Debugged issue”, “Fixed typo” veya “Updated README” gibi commitler. Squash and Merge, tüm bu commit’leri anlamlı ve özetleyici <strong>tek bir commit</strong> haline getirerek geçmişi temiz ve okunabilir kılar.</p><h4><strong>Kod İncelemesini Kolaylaştırması</strong></h4><p>Tek bir commit üzerinden yapılan değişiklikleri gözden geçirmek, özellikle <strong>pull request</strong> süreçlerinde ekip üyelerinin işini kolaylaştırır. Değişiklikleri tek bir noktadan incelemek, zamandan tasarruf sağlar ve sürecin daha akıcı olmasını sağlar.</p><h4><strong>Daha İyi Bir Proje Organizasyonu</strong></h4><p>Commit geçmişindeki fazlalıklardan kurtularak, gelecekte projeyi devralacak ekip üyelerinin projeyi anlamasını kolaylaştırır. <strong>Karmaşık geçmişler</strong>, teknik borcu büyütürken Squash and Merge ile bu borç en aza indirilir.</p><h4><strong>Hataların Hızlı Tespiti</strong></h4><p>Daha temiz bir geçmiş, gelecekte bir sorunun kaynağını hızlıca bulmayı ve düzeltmeyi kolaylaştırır. Özellikle geçmiş değişiklikleri analiz ederken <strong>düzenli bir commit yapısı</strong>, büyük bir avantaj sağlar.</p><h3><strong>Avantajları</strong></h3><h4><strong>Sadelik</strong></h4><p>Tüm commit’leri birleştirerek gereksiz detaylardan arındırılmış bir commit geçmişi sunar.</p><h4><strong>İletişim ve İş Birliği</strong></h4><p>Ekip üyeleri arasında değişikliklerin net anlaşılmasını sağlar, bu da iş birliğini artırır.</p><h4><strong>Pull Request Başlıklarının Standardizasyonu</strong></h4><p>Squash and Merge kullanırken <strong>pull request başlıklarının dikkatlice yazılması</strong>, gelecekteki ekip üyeleri için net bir yönlendirme sağlar. GitHub gibi platformlar varsayılan olarak bu başlığı alır; bu da başlık standardı belirleyerek commit geçmişini daha anlamlı hale getirir.</p><h4><strong>Daha Temiz Bir İş Akışı</strong></h4><p>Özellikle bir feature branch tamamlandığında, tüm geliştirme süreci tek bir anlamlı commit’te özetlenebilir.</p><h3><strong>Dezavantajları</strong></h3><h4><strong>Commit Detaylarının Kaybı</strong></h4><p>Küçük commit’lerde yer alan bazı önemli detaylar, squash sırasında kaybolabilir. Örneğin, bir bug fix için yapılan küçük adımları anlamak zorlaşabilir.</p><h4><strong>Yanlış Commit Mesajları</strong></h4><p>Squash sırasında <strong>pull request başlığını dikkatlice düzenlememek</strong>, gelecekte anlaşılabilirliği zorlaştırabilir.</p><h4><strong>Herkesin Alışması Gerekebilir</strong></h4><p>Ekip üyeleri, squash işlemini doğru bir şekilde uygulamayı öğrenmek zorundadır. Yanlış bir işlem, commit geçmişini karışık hale getirebilir.</p><h3><strong>Neden Squash and Merge Kullanılır?</strong></h3><h4><strong>Geliştirme Süreçlerinde Hız ve Netlik</strong></h4><p>Büyük projelerde, özellikle birden fazla kişi aynı branch üzerinde çalışırken, commit geçmişini kontrol etmek karmaşık hale gelebilir. Squash and Merge, bu karmaşayı düzene sokar.</p><h4><strong>Pull Request Süreçlerinde Kolaylık</strong></h4><p>Değişiklikleri birleştirmeden önce daha net bir yapı sağlar. Özellikle yeni bir özelliğin eklenmesi ya da bir hata düzeltmesi gibi durumlarda, tek bir commit tüm süreci özetler.</p><h4><strong>Teknik Borcun Azaltılması</strong></h4><p>Her commit’in, projenin uzun vadeli sürdürülebilirliğine katkıda bulunmasını sağlar. Squash and Merge, gereksiz commit’lerden kaynaklanan teknik borcu azaltarak ekiplerin daha hızlı ilerlemesine yardımcı olur.</p><h3><strong>Dikkat Edilmesi Gerekenler</strong></h3><h4><strong>Pull Request Başlıklarına Dikkat Edin</strong></h4><p>Squash işlemi sırasında yazılacak <strong>pull request başlığı</strong>, yapılan tüm değişiklikleri özetlemelidir. GitHub gibi platformlar varsayılan olarak bu başlığı kullandığı için, belirsiz mesajlar gelecekteki ekip üyeleri için sorun yaratabilir. Bu nedenle başlıkların proje standartlarına uygun ve açıklayıcı olması önemlidir.</p><h4><strong>Doğru Yerlerde Kullanın</strong></h4><p>Squash and Merge her zaman uygun değildir. Örneğin, bir feature branch üzerinde detaylı bir commit geçmişi önemliyse, squash işlemi yerine geleneksel merge tercih edilebilir.</p><p>Squash and Merge, <strong>commit geçmişinizi temizlemek</strong>, ekip içi iş birliğini artırmak ve projelerin sürdürülebilirliğini sağlamak için etkili bir özelliktir. Pull request başlıklarını düzenli ve anlamlı tutarak, hem projenizi daha kolay yönetilebilir bir hale getirebilir hem de ekip iletişimini güçlendirebilirsiniz 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41aa5b93992c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Neden Swagger Yerine Postman Tercih Etmelisiniz?]]></title>
            <link>https://medium.com/@agitrubard/neden-swagger-yerine-postman-tercih-etmelisiniz-9aa9aad164b6?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/9aa9aad164b6</guid>
            <category><![CDATA[swagger]]></category>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[api-development]]></category>
            <category><![CDATA[postman-collections]]></category>
            <category><![CDATA[api-documentation]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Fri, 13 Dec 2024 07:31:33 GMT</pubDate>
            <atom:updated>2026-07-15T19:32:50.421Z</atom:updated>
            <content:encoded><![CDATA[<p>Postman, API geliştirme süreçlerinde genellikle bir test aracı olarak bilinse de, çok daha fazlasını sunar. API dokümantasyonu, otomasyon ve ekip içi iş birliği gibi alanlarda güçlü özelliklere sahip olan Postman, projenizin her aşamasında size destek olabilir. Bu yazıda, Postman’i profesyonel bir araç olarak nasıl kullanabileceğinizi ve Swagger’a kıyasla neden tercih edilebileceğini anlatacağım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eArznjvFR3E6ETimCMew1A.jpeg" /></figure><h3><strong>Neden Postman Tercih Edilmeli?</strong></h3><p>Çoğu geliştirici ve ekip, API dokümantasyonu için Swagger gibi araçları tercih ediyor. Ancak Postman, çok yönlü özellikleriyle sadece test aşamasında değil, projenin her adımında büyük avantajlar sunar.</p><h4><strong>Hızlı Başlangıç</strong></h4><p>Postman’in kullanıcı dostu arayüzü, API testlerine ve dokümantasyon oluşturmaya hızla başlamanızı sağlar.</p><h4><strong>Geniş Yetkinlikler</strong></h4><p>API testi, dokümantasyon, entegrasyon ve otomasyon gibi çok yönlü özellikler sunar.</p><h4><strong>Ekip İçi İş Birliği</strong></h4><p>Collection paylaşımı, geri bildirim ekleme ve merkezi çalışma alanlarıyla ekipler daha etkili çalışabilir.</p><blockquote><strong>Postman, API geliştirme süreçlerini basitleştirerek karmaşık projelerde bile verimliliği artırır.</strong></blockquote><h3><strong>Postman’in Gücünden Nasıl Yararlanabilirsiniz?</strong></h3><h4><strong>Postman Collections</strong></h4><p>Postman Collections ile API isteklerinizi düzenleyebilir ve erişilebilir hale getirebilirsiniz.</p><ul><li>API çağrılarını mantıklı bir şekilde gruplandırabilirsiniz.</li><li>Ekip üyeleriyle paylaşarak proje boyunca tutarlılık sağlayabilirsiniz.</li><li>Her bir API çağrısına açıklama ve örnek ekleyerek dokümantasyon süreçlerini kolaylaştırabilirsiniz.</li></ul><h4><strong>Postman Environment</strong></h4><p>Farklı ortamlar (örneğin, development, staging, production) için değişkenler tanımlayabilirsiniz.</p><ul><li>API çağrılarını farklı ortamlarda test edebilir ve kolayca uyarlayabilirsiniz.</li><li>Ortama özel değişkenlerle aynı Collection’ı farklı senaryolarda kullanabilirsiniz.</li></ul><h4><strong>Pre-Request Script</strong></h4><p>API çağrılarından önce çalışacak küçük kodlar (script’ler) yazarak süreci otomatikleştirebilirsiniz.</p><ul><li>Yetkilendirme token’larını dinamik olarak oluşturabilirsiniz.</li><li>Zaman damgaları veya rastgele parametreler ekleyerek testlerinizi zenginleştirebilirsiniz.</li></ul><h4><strong>Postman API Documentation</strong></h4><p>Postman’in sunduğu otomatik dokümantasyon özelliği ile API’lerinizi anlaşılır bir rehbere dönüştürebilirsiniz.</p><ul><li>Koleksiyonlarınızdaki tüm çağrıları, parametreleri ve yanıt örneklerini detaylı bir şekilde dokümante edebilirsiniz.</li><li>Bu dokümantasyonu bir bağlantı aracılığıyla ekip üyeleri ve müşterilerinizle paylaşabilirsiniz.</li></ul><h3><strong>Postman’i API Dokümantasyonu için Kullanmak</strong></h3><p>Postman, yalnızca bir test aracı değil, aynı zamanda kapsamlı bir API dokümantasyonu platformudur.</p><p>İşte API geliştirirken Postman’i daha profesyonel bir şekilde kullanabileceğiniz yöntemler ve örnekler:</p><h4><strong>Collection’lar oluşturabilirsiniz</strong></h4><ul><li>API çağrılarını düzenli bir yapıya oturtarak her bir isteğin amacını net bir şekilde belirtebilirsiniz.</li><li>Örneğin, bir ödeme sistemini geliştirirken, her bir API çağrısını (ödeme başlatma, durumu kontrol etme, iptal etme) ayrı bir düzen içerisinde gruplandırabilirsiniz. Bu, geliştiricilerin test sürecini daha net bir şekilde takip etmesini sağlar.</li></ul><h4><strong>Environment’lar tanımlayabilirsiniz</strong></h4><ul><li>Ortama bağlı değişkenlerle API’lerinizi farklı senaryolara adapte edebilirsiniz.</li><li>Ortam değişkenleri sayesinde, aynı API’yi hem “test” hem de “production” ortamlarında kolayca test edebilirsiniz. Örneğin, https://test-api.example.com ve https://prod-api.example.com adreslerini bir “API_URL” değişkeni olarak tanımlayarak çağrılarınızı dinamik hale getirebilirsiniz.</li></ul><h4><strong>Pre-Request script’lerle otomasyon sağlayabilirsiniz</strong></h4><ul><li>API çağrılarında otomatik işlemler gerçekleştirebilirsiniz.</li><li>Her istekten önce bir “authorization token” oluşturmanız mı gerekiyor? Pre-Request script’ler ile bu işlemi otomatikleştirebilir ve manuel iş yükünü ortadan kaldırabilirsiniz.</li></ul><h4><strong>Dokümantasyon oluşturabilirsiniz</strong></h4><ul><li>Postman Collectionlarınızı dışarıya açık bir API dokümanına dönüştürebilirsiniz. Bu dokümanlar, otomatik olarak URL ile paylaşılabilir.</li><li>Örneğin, ekibinizin hızlıca erişebileceği ve değişiklikleri gerçek zamanlı görebileceği bir dokümantasyon oluşturmak, hem ekip içi hem de müşteri iletişimini kolaylaştırır.</li></ul><p>Bu özelliklerin tümü bir araya geldiğinde, API geliştirme ve dokümantasyon süreçleriniz hem daha verimli hem de profesyonel hale gelir. Özellikle karmaşık projelerde, Postman’in sunduğu araçlar süreçleri standartlaştırmanıza ve ekip içi iş birliğini artırmanıza yardımcı olur.</p><p>Postman’i yalnızca bir test aracı olarak kullanmak yerine, onun sunduğu tüm potansiyeli keşfederek projelerinize değer katabilirsiniz. Daha fazla bilgi için bana ulaşabilirsiniz! 👨‍💻</p><h4>Gerçek Hayat Örneği</h4><p>Afet Yönetim Sistemi projesinin herkese açık olan Postman API dokümantasyonunu aşağıdaki bağlantı aracılığıyla inceleyebilirsiniz;<br><a href="https://documenter.getpostman.com/view/26813504/2sBXcKAcdv">https://documenter.getpostman.com/view/26813504/2sBXcKAcdv</a></p><h4>Yararlanabileceğiniz Postman Dokümantasyonları</h4><ul><li><a href="https://learning.postman.com/docs/collections/collections-overview/">https://learning.postman.com/docs/collections/collections-overview/</a></li><li><a href="https://learning.postman.com/docs/sending-requests/variables/variables-intro/">https://learning.postman.com/docs/sending-requests/variables/variables-intro/</a></li><li><a href="https://learning.postman.com/docs/tests-and-scripts/write-scripts/pre-request-scripts/">https://learning.postman.com/docs/tests-and-scripts/write-scripts/pre-request-scripts/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9aa9aad164b6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HexaLayered Architecture]]></title>
            <link>https://medium.com/@agitrubard/hexalayered-architecture-d49ffdc97bb8?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/d49ffdc97bb8</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[layered-architecture]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[hexalayered-architecture]]></category>
            <category><![CDATA[hexagonal-architecture]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Mon, 28 Oct 2024 09:32:08 GMT</pubDate>
            <atom:updated>2024-10-28T16:49:36.490Z</atom:updated>
            <content:encoded><![CDATA[<p>HexaLayered Architecture is an innovative architectural approach developed for Spring Boot applications, combining the advantages of Hexagonal (Ports and Adapters) and Layered architectures. This architecture aims to develop scalable and sustainable applications by combining modularity and simplicity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jOGJg0-lnJYvmbuVzQllUA.jpeg" /></figure><h3>Basic Principles</h3><p><strong>1. Modularity</strong><br>Each module is independent in itself and isolated from other modules.</p><p><strong>2. Layered Structure</strong><br>The application is divided into layers with specific responsibilities.</p><p><strong>3. Port and Adapter Distinction</strong><br>Communication with external systems is provided through ports and adapters.</p><p><strong>4. Domain Focused Design</strong><br>Business logic is shaped around domain objects.</p><h3>Architectural Layers</h3><p><strong>1. Controller Layer</strong><br>HTTP meets requests and manages responses.</p><p><strong>2. Service Layer</strong><br>It contains business logic and performs operations on domain objects.</p><p><strong>3. Port/Adapter Layer</strong><br>It provides communication with external systems and transforms domain objects.</p><p><strong>4. Repository Layer</strong><br>Performs database operations.</p><h3>Advantages</h3><p><strong>1. Flexibility</strong><br>Interaction with external systems can be easily changed.</p><p><strong>2. Testability</strong><br>Each layer can be tested independently.</p><p><strong>3. Ease of Maintenance</strong><br>Simple, clean and organized construction facilitates long-term maintenance.</p><p><strong>4. Scalability</strong><br>The modular structure supports the growth of the application.</p><h3>Projects Using HexaLayered Architecture</h3><p>You can review the following open source projects to see real-world applications of HexaLayered Architecture:</p><h4><strong>Afet Yönetim Sistemi | AYS</strong></h4><p>HexaLayered Architecture is an example of an application that is best applied, complex and used in critical situations.</p><p><a href="https://github.com/afet-yonetim-sistemi/ays-be">https://github.com/afet-yonetim-sistemi/ays-be</a></p><p>• Modular structure<br>• End-to-end error management<br>• Extended search and filtering features<br>• Extensive test infrastructure<br>• Advanced security and authorization features</p><h4><strong>Gelecek Bilimde</strong></h4><p>It is an example of an application that HexaLayered Architecture is best applied and used for content and user management.</p><p><a href="https://github.com/gelecekbilimde/backend">https://github.com/gelecekbilimde/backend</a></p><p>• Modular structure<br>• End-to-end error management<br>• Extended search and filtering features<br>• Security and authorization features</p><p>These projects show how HexaLayered Architecture is applied in different usage scenarios. Since both projects are open source, you can examine their codes and see the practical applications of the architecture in detail.</p><h3>Conclusion</h3><p>HexaLayered Architecture offers a flexible, sustainable and understandable architectural solution for modern Spring Boot applications. Using this architecture, you can develop applications that are more modular, testable and easy to maintain.</p><p>You can use the README.md file in the repository for technical details of HexaLayered Architecture.</p><p>🚀 <a href="https://github.com/agitrubard/hexalayered-architecture">https://github.com/agitrubard/hexalayered-architecture</a></p><h4>Contribution</h4><p>We look forward to your contributions to developing and improving HexaLayered Architecture. You can share your ideas or suggestions you find on GitHub.</p><p>If you have developed a project using HexaLayered Architecture and would like to list it in README.md, please let me know!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d49ffdc97bb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot Uygulamalarında Test Stratejileri: Gerçek Hayat Deneyimleri ve En İyi Pratikler]]></title>
            <link>https://medium.com/@agitrubard/spring-boot-uygulamalarinda-test-stratejileri-gercek-hayat-deneyimleri-ve-en-iyi-pratikler-7b4c4bda8551?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b4c4bda8551</guid>
            <category><![CDATA[end-to-end-testing]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[integration-testing]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Mon, 21 Oct 2024 09:47:37 GMT</pubDate>
            <atom:updated>2024-10-21T09:47:37.486Z</atom:updated>
            <content:encoded><![CDATA[<p>Yazılım geliştirme sürecinde testler, projenin başarısı için hayati öneme sahiptir. Özellikle Spring Boot gibi güçlü bir framework ile çalışırken, doğru test stratejileri uygulamak, uygulamamızın güvenilirliğini ve sürdürülebilirliğini artırır. Bu yazıda, gerçek hayat deneyimlerimizden yola çıkarak Spring Boot uygulamalarında test stratejilerinin nasıl uygulandığını ve bunların pratikte nasıl fayda sağladığını inceleyeceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GFw3gqLsTHB-Z_8qM7Ci5g.jpeg" /></figure><h3>Neden Test Yazmalıyız?</h3><p>Test yazmak, birçok geliştirici tarafından zaman kaybı olarak görülebilir.</p><p>Ancak uzun vadede düşünüldüğünde, iyi yazılmış testler:<br><strong>1. </strong>Hataları erken aşamada yakalamamızı sağlar.<br><strong>2. </strong>Kodun güvenilirliğini artırır.<br><strong>3. </strong>Refactoring süreçlerini kolaylaştırır.<br><strong>4. </strong>Dokümantasyon görevi görür.<br><strong>5. </strong>Geliştirme sürecini hızlandırır.</p><blockquote><strong>Kısa vadede zaman kaybı gibi görünen testler, aslında uzun vadede büyük bir zaman kazancı sağlar.</strong></blockquote><h3>Test Tipleri</h3><h4>1. Unit Test (Birim Testi)</h4><p>Unit testler, kodumuzun en küçük parçalarını (genellikle metodları) izole bir şekilde test etmemizi sağlar.</p><blockquote><strong>Karmaşık iş mantığı içeren servis katmanları için idealdir. Hızlı çalışır ve spesifik fonksiyonaliteyi test eder.</strong></blockquote><p><strong>Özellikler:</strong><br><strong>•</strong> Genellikle service veya spesifik uygulama sınıfları için yazılır (örn. UserServiceImpl, UserPersistenceAdapter).<br><strong>•</strong> Mockito gibi araçlar kullanılarak bağımlılıklar mocklanır.<br><strong>•</strong> Sadece test edilen metodun davranışına odaklanılır.<br><strong>•</strong> Çok hızlı çalışır ve sık sık çalıştırılabilir.</p><p><strong>Avantajlar:</strong><br><strong>•</strong> Kodun belirli bir parçasının doğru çalıştığından emin olunur.<br><strong>•</strong> Hataları hızlı bir şekilde izole etmeyi sağlar.<br><strong>• </strong>Refactoring sırasında güven verir.</p><p><strong>Dezavantajlar:</strong><br><strong>•</strong> Bileşenler arasındaki etkileşimleri test etmez.<br><strong>•</strong> Aşırı mocklama, gerçek davranıştan uzaklaşmaya neden olabilir.</p><p><strong>Pratik İpuçları:<br>• </strong>Her bir test metodu için tek bir senaryo test edin.<br><strong>• </strong>Edge case’leri ve hata senaryolarını da test etmeyi unutmayın.<br><strong>• </strong>Test yazarken kod yazarmış gibi düşünmeyip, ortaklaştırma yapmamaya çalışın. Testleriniz açık bir şekilde yazılmalı ve okunabilir olmalıdır.</p><p><strong>Kod Örneği:</strong></p><pre>@Test<br>void givenValidId_whenUserFoundById_thenReturnUser() {<br><br>    // Given<br>    Institution mockInstitution = new InstitutionBuilder()<br>            .withValidValues()<br>            .build();<br>    Mockito.when(identity.getInstitutionId())<br>            .thenReturn(mockInstitution.getId());<br><br>    AysUser mockUser = new AysUserBuilder()<br>            .withValidValues()<br>            .withInstitution(mockInstitution)<br>            .build();<br>    String mockId = mockUser.getId();<br><br>    // When<br>    Mockito.when(userReadPort.findById(mockId))<br>            .thenReturn(Optional.of(mockUser));<br><br>    // Then<br>    AysUser user = userReadService.findById(mockId);<br><br>    Assertions.assertNotNull(user);<br>    Assertions.assertEquals(mockUser, user);<br><br>    // Verify<br>    Mockito.verify(identity, Mockito.times(1))<br>            .getInstitutionId();<br><br>    Mockito.verify(userReadPort, Mockito.times(1))<br>            .findById(Mockito.anyString());<br>}</pre><blockquote><a href="https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/service/impl/AysUserReadServiceImplTest.java#L115">https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/service/impl/AysUserReadServiceImplTest.java#L115</a></blockquote><h4>2. Integration Test (Entegrasyon Testi)</h4><p>Integration testler, farklı bileşenlerin birlikte nasıl çalıştığını kontrol eder.</p><blockquote><strong>Controller’ların doğru çalıştığını, veritabanı işlemlerinin beklendiği gibi gerçekleştiğini veya harici servislerle iletişimin düzgün kurulduğunu kontrol etmek için kullanılır.</strong></blockquote><p><strong>Özellikler:</strong><br><strong>•</strong> Controller, repository veya Kafka, Redis gibi dış bağımlılıklar için yazılabilir.<br><strong>•</strong> MockMvc kullanılarak HTTP istekleri simüle edilir.<br><strong>•</strong> Bağımlılıklar Mockito ile mocklenebilir, ancak gerçek bağımlılıkları kullanmak da mümkündür.<br><strong>• </strong>Uygulamanın çalışmasını gerektirdiği için unit testlere kıyasla daha yavaş çalışır, ancak daha gerçekçi senaryoları test eder.</p><p><strong>Avantajlar:<br>• </strong>Bileşenlerin birlikte doğru çalıştığını doğrular.<br><strong>• </strong>API sözleşmelerinin doğru uygulandığını kontrol eder.<br><strong>• </strong>Veritabanı işlemlerini gerçek bir ortamda test edebilir.</p><p><strong>Dezavantajlar:<br>• </strong>Unit testlere göre daha yavaş çalışır.<br><strong>• </strong>Hataların kaynağını belirlemek daha zor olabilir.</p><p><strong>Pratik İpuçları:<br>• </strong>Test veritabanı olarak H2 gibi in-memory veritabanları kullanın.<br><strong>• </strong>Her testten önce veritabanını temizleyin veya sıfırlayın.<br><strong>• </strong>Gerçek HTTP isteklerini simüle etmek için MockMvc kullanın.<br><strong>• </strong>API’nizin farklı HTTP metodlarını (GET, POST, PUT, DELETE, etc.) test edin.<br><strong>• </strong>Hata durumlarını ve sınır koşullarını da test etmeyi unutmayın.</p><p><strong>Kod Örneği:</strong></p><pre>@Test<br>void givenValidUserId_whenUserFound_thenReturnAysUserResponse() throws Exception {<br><br>    // Given<br>    String mockUserId = AysRandomUtil.generateUUID();<br><br>    // When<br>    AysUser mockUser = new AysUserBuilder()<br>            .withValidValues()<br>            .withId(mockUserId)<br>            .build();<br><br>    Mockito.when(userReadService.findById(mockUserId))<br>            .thenReturn(mockUser);<br><br>    // Then<br>    String endpoint = BASE_PATH.concat(&quot;/user/&quot;).concat(mockUserId);<br>    MockHttpServletRequestBuilder mockHttpServletRequestBuilder = AysMockMvcRequestBuilders<br>            .get(endpoint, mockAdminToken.getAccessToken());<br><br>    AysUserResponse mockUserResponse = userToResponseMapper<br>            .map(mockUser);<br>    AysResponse&lt;AysUserResponse&gt; mockResponse = AysResponse<br>            .successOf(mockUserResponse);<br><br>    aysMockMvc.perform(mockHttpServletRequestBuilder, mockResponse)<br>            .andExpect(AysMockResultMatchersBuilders.status()<br>                    .isOk())<br>            .andExpect(AysMockResultMatchersBuilders.response()<br>                    .isNotEmpty());<br><br>    // Verify<br>    Mockito.verify(userReadService, Mockito.times(1))<br>            .findById(mockUserId);<br>}</pre><blockquote><a href="https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/controller/AysUserControllerTest.java#L272">https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/controller/AysUserControllerTest.java#L272</a></blockquote><h4>3. End-to-End Test (Uçtan Uca Test)</h4><p>End-to-End testler, uygulamanın tüm bileşenlerinin birlikte çalışmasını uçtan uca test eder. User Acceptance Test olarak da bilinir.</p><blockquote><strong>Kullanıcı senaryolarını tam olarak test etmek ve sistemin bir bütün olarak çalıştığından emin olmak için kullanılır.</strong></blockquote><p><strong>Özellikler:</strong><br><strong>•</strong> Gerçek bir kullanıcı senaryosunu simüle eder.<br><strong>•</strong> Tüm katmanlar ve bağımlılıklar gerçek ortamda test edilir.<br><strong>•</strong> Testcontainers gibi araçlar kullanılarak gerçekçi ortamlar oluşturulabilir.<br><strong>• </strong>En yavaş çalışan, ancak en kapsamlı test tipidir.</p><p><strong>Avantajlar:<br>• </strong>Uygulamanın gerçek dünya senaryolarında nasıl davrandığını gösterir.<br><strong>• </strong>Tüm sistem bileşenlerinin entegrasyonunu doğrular.<br><strong>• </strong>Kullanıcı deneyimini simüle eder.</p><p><strong>Dezavantajlar:<br>• </strong>Çalıştırması zaman alır ve kaynak yoğundur.<br><strong>• </strong>Hataların kaynağını belirlemek zor olabilir.<br><strong>• </strong>Bakımı diğer test tiplerine göre daha zordur.</p><p><strong>Pratik İpuçları:<br>• </strong>Uçtan uca testlerin gerçekleştirilebilmesi için H2 yerine Testcontainers kullanarak gerçek veritabanı ve diğer bağımlılıkları (örn. MySQL, Redis, Kafka) simüle edin.<br><strong>• </strong>Tam bir kullanıcı akışını test edin (CRUD operasyonları).<br><strong>• </strong>Test verilerini önceden hazırlayın ve her testten sonra temizleyin.<br><strong>• </strong>Asenkron işlemleri test ederken uygun bekleme mekanizmaları kullanın.<br><strong>• </strong>Performans sorunlarını tespit etmek için zamanlama ölçümleri ekleyin.</p><p><strong>Kod Örneği:</strong></p><pre>@Test<br>void givenValidUserId_whenUserExists_thenReturnUserResponse() throws Exception {<br><br>    // Initialize<br>    Institution institution = new InstitutionBuilder()<br>            .withId(AysValidTestData.Admin.INSTITUTION_ID)<br>            .build();<br><br>    AysRole role = roleReadPort.findAllActivesByInstitutionId(institution.getId())<br>            .stream()<br>            .findFirst()<br>            .orElseThrow();<br><br>    AysUser user = userSavePort.save(<br>            new AysUserBuilder()<br>                    .withValidValues()<br>                    .withoutId()<br>                    .withRoles(List.of(role))<br>                    .withInstitution(institution)<br>                    .build()<br>    );<br><br>    // Given<br>    String userId = user.getId();<br><br>    // Then<br>    String endpoint = BASE_PATH.concat(&quot;/user/&quot;).concat(userId);<br>    MockHttpServletRequestBuilder mockHttpServletRequestBuilder = AysMockMvcRequestBuilders<br>            .get(endpoint, adminToken.getAccessToken());<br><br>    AysUserResponse mockUserResponse = userToResponseMapper<br>            .map(user);<br><br>    AysResponse&lt;AysUserResponse&gt; mockResponse = AysResponse<br>            .successOf(mockUserResponse);<br><br>    aysMockMvc.perform(mockHttpServletRequestBuilder, mockResponse)<br>            .andExpect(AysMockResultMatchersBuilders.status()<br>                    .isOk())<br>            .andExpect(AysMockResultMatchersBuilders.response()<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;id&quot;)<br>                    .value(user.getId()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;emailAddress&quot;)<br>                    .value(user.getEmailAddress()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;firstName&quot;)<br>                    .value(user.getFirstName()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;lastName&quot;)<br>                    .value(user.getLastName()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;phoneNumber.countryCode&quot;)<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;phoneNumber.lineNumber&quot;)<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;city&quot;)<br>                    .value(user.getCity()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;status&quot;)<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;roles[*].id&quot;)<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;roles[*].name&quot;)<br>                    .isNotEmpty())<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;createdUser&quot;)<br>                    .value(user.getCreatedUser()))<br>            .andExpect(AysMockResultMatchersBuilders.response(&quot;createdAt&quot;)<br>                    .isNotEmpty());<br>}</pre><blockquote><a href="https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/controller/AysUserEndToEndTest.java#L183">https://github.com/afet-yonetim-sistemi/ays-be/blob/bfaaa8fdb3f205b4f4d87ad90e3c018abf0c2b35/src/test/java/org/ays/auth/controller/AysUserEndToEndTest.java#L183</a></blockquote><h3>Sonuç</h3><p>Spring Boot uygulamalarında farklı test tiplerini kullanmak, uygulamamızın güvenilirliğini ve kalitesini artırır. Her bir test tipi, farklı senaryoları ve kullanım durumlarını kapsar. Başlangıçta zaman alıcı görünse de, uzun vadede bu testler geliştirme sürecini hızlandırır, hataları azaltır ve kodun sürdürülebilirliğini artırır.</p><p>Unutmayın, iyi bir test stratejisi, projenizin başarısı için kritik öneme sahiptir. Test yazmayı ihmal etmeyin ve bu farklı test tiplerini projenizin ihtiyaçlarına göre dengeli bir şekilde kullanın.</p><p><strong>Gerçek hayatta kullanımları için, aşağıdaki açık kaynak repoyu inceleyebilirsiniz;<br></strong><a href="https://github.com/afet-yonetim-sistemi/ays-be/tree/main/src/test/java/org/ays">https://github.com/afet-yonetim-sistemi/ays-be/tree/main/src/test/java/org/ays</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b4c4bda8551" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[java.util.Date Kullanmayı Acilen Bırakmalısınız: Modern Alternatifler ve Nedenleri]]></title>
            <link>https://medium.com/@agitrubard/java-util-date-kullanmayi-acilen-birakmalisiniz-modern-alternatifler-ve-nedenleri-6da0b14e7a68?source=rss-63fe19de2b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/6da0b14e7a68</guid>
            <category><![CDATA[java-time]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Agit Rubar Demir]]></dc:creator>
            <pubDate>Mon, 23 Sep 2024 10:17:01 GMT</pubDate>
            <atom:updated>2024-09-23T12:14:49.549Z</atom:updated>
            <content:encoded><![CDATA[<p>Java dünyasında, <strong>java.util.Date</strong> sınıfı uzun yıllardır tarih ve zaman işlemleri için kullanılan bir sınıf olsa da, artık <strong>önerilmeyen</strong> ve yerini çok daha güçlü ve kullanışlı sınıflara bırakan bir yapı haline geldi. <strong>java.util.Date</strong> sınıfının bazı bölümleri resmi olarak “<strong>deprecated</strong>” olarak işaretlenmiş olup, yerini <strong>java.time</strong> paketindeki modern sınıflara bırakmıştır. Peki neden bu değişime ihtiyaç var? Gelin, detaylarına inelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UQ1ykPYaDgDZu8AOUCz47A.jpeg" /></figure><h3><strong>Deprecate Edilen Metotlar</strong></h3><p>java.util.Date sınıfındaki birçok metodun artık kullanılması önerilmemektedir.</p><p><strong>Örneğin:</strong><br>- getYear()<br>- getMonth()<br>- getDay()</p><p>Bu metodlar artık <strong>Java tarafından önerilmemektedir</strong> ve eski tarih yöntemlerini kullanarak kod yazmanız, birçok sorunla karşılaşmanıza neden olabilir.</p><h3><strong>Neden java.util.Date Önerilmiyor?</strong></h3><p><strong>java.util.Date</strong> sınıfı, ilk tasarlandığı zamanın ihtiyaçlarına göre basit ve hızlı bir şekilde kullanıldı. Ancak zamanla sınıfın eksiklikleri ve yetersizlikleri belirgin hale geldi.</p><p><strong>java.util.Date</strong> yerine modern alternatifler kullanmanız gerektiğine dair başlıca sebepler:</p><h4><strong>Hatalara Açık Yapı</strong></h4><p>java.util.Date hem mutable (değiştirilebilir) bir sınıftır hem de thread-safe değildir. Bu nedenle bir tarih nesnesi üzerinde işlem yaparken istem dışı sonuçlar ve veri tutarsızlıkları oluşabilir.</p><h4><strong>Yanlış Tasarım</strong></h4><p>Aylar sıfırdan başlar (Ocak = 0), yıllar 1900’den itibaren hesaplanır, bu da kodun anlaşılmasını ve bakımını zorlaştırır.</p><h4><strong>Eksik Fonksiyonlar</strong></h4><p>Zaman dilimleri, tarih aralıkları gibi birçok önemli özellik, java.util.Date sınıfında yer almıyor.</p><h3><strong>Modern Alternatifler: java.time Paketinin Gücü</strong></h3><p>Java 8 ile birlikte tanıtılan <strong>java.time</strong> paketi, tarih ve zaman işlemlerinde çok <strong>daha güçlü</strong>, <strong>güvenli</strong> ve <strong>anlaşılır</strong> bir yapı sunuyor.</p><h4><strong>java.time.LocalDateTime</strong></h4><p>Hem tarih hem saat bilgisini tutar.</p><h4>java.time.LocalDate</h4><p>Sadece tarih bilgisini tutar. Saat kısmı yoktur.</p><h4>java.time.LocalTime</h4><p>Sadece saat bilgisini tutar. Tarih bilgisi içermez.</p><h3>Neden Bu Sınıfları Tercih Etmeliyiz?</h3><h4><strong>Immutable (Değişmez) Yapı</strong></h4><p>Bir kez oluşturduktan sonra bu nesneler üzerinde değişiklik yapamazsınız. Bu, hataları ve thread-safety problemlerini önler.</p><h4><strong>Daha Anlaşılır API</strong></h4><p>Yılların ve ayların 1900 ya da sıfır bazlı olması gibi sorunlar ortadan kaldırılmıştır.</p><h4><strong>Kapsamlı Zaman ve Tarih İşlemleri</strong></h4><p>Zaman dilimleri, tarih aralıkları, saat farkları gibi işlemleri çok daha kolay bir şekilde yapabilirsiniz.</p><h3><strong>Gerçek Hayat Senaryosu: Ücret Hesaplama Örneği</strong></h3><p>Eski <strong>java.util.Date</strong> yapısıyla bir tarih işlemi yapmanın ne kadar <strong>karmaşık olduğu</strong>nu ve <strong>modern java.time</strong> sınıflarının bu durumu nasıl kolaylaştırdığını bir örnekle gösterelim.</p><h4><strong>Modern Yöntem: java.time.LocalDateTime Kullanımı</strong></h4><pre>import java.time.Duration;<br>import java.time.LocalDateTime;<br><br>public class ModernSolution {<br><br>    void main() {<br>        <br>        int hourlyRate = 100;<br>        double minuteRate = hourlyRate / 60.0;<br><br>        LocalDateTime startDateTime = LocalDateTime.now();<br>        LocalDateTime endDateTime = LocalDateTime.now()<br>                .plusHours(1)<br>                .plusMinutes(20);<br><br>        double minutes = Duration.between(startDateTime, endDateTime).toMinutes();<br><br>        System.out.printf(&quot;Fee: $%f\n&quot;, (minutes * minuteRate));<br><br>    }<br>}</pre><p>Bu senaryoda, iki tarih arasında geçen süreyi hesaplayıp, ücretlendirme işlemini yapıyoruz. <strong>LocalDateTime</strong> sınıfı ile işlem yapmak oldukça <strong>kolay</strong> ve <strong>anlaşılır</strong>.</p><h4><strong>Eski Yöntem: java.util.Date Kullanımı</strong></h4><p>Eğer bu işlemi <strong>java.util.Date</strong> ile yapmaya çalışsaydık, <strong>çok daha karmaşık bir kod</strong>la karşı karşıya kalırdık. Zaman aralığını hesaplamak için<strong> ekstra kodlar</strong> ve Calendar sınıfı gibi destekleyici yapılar kullanmamız gerekirdi.</p><p>Aynı işlemi eski yöntemle yapmak şu şekilde olurdu:</p><pre>import java.util.Date;<br>import java.util.concurrent.TimeUnit;<br><br>public class OldSolution {<br><br>    void main() {<br>        <br>        int hourlyRate = 100;<br>        double minuteRate = hourlyRate / 60.0;<br><br>        Date startDateTime = new Date();<br>        Date endDateTime = new Date(startDateTime.getTime() + TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(20));<br><br>        long durationInMillis = endDateTime.getTime() - startDateTime.getTime();<br>        long minutes = TimeUnit.MILLISECONDS.toMinutes(durationInMillis);<br><br>        System.out.printf(&quot;Fee: $%f\n&quot;, (minutes * minuteRate));<br><br>    }<br>}</pre><p>Gördüğünüz gibi, <strong>java.util.Date</strong> ile aynı işlemi yapmak <strong>çok daha karışık</strong> ve <strong>hata yapmaya açık</strong> hale geliyor. <strong>java.time.LocalDateTime</strong> ise hem <strong>daha temiz</strong> hem de <strong>daha anlaşılır</strong> bir yapı sunuyor.</p><h3><strong>Sonuç</strong></h3><p><strong>java.util.Date sınıfı</strong> artık önerilmeyen, <strong>karmaşık</strong> ve <strong>hataya açık</strong> bir yapıdır. Yerine <strong>modern</strong>, <strong>immutable</strong> ve <strong>daha güvenli</strong> olan <strong>java.time sınıfları</strong>nı kullanmanız, hem <strong>kodunuzu temiz tutar</strong> hem de <strong>ileride yaşanabilecek hataların önüne geçer</strong>.</p><p>Eğer hala <strong>java.util.Date kullanıyorsanız</strong>, <strong>kodlarınızı güncellemeyi</strong> ve <strong>modern alternatiflere geçmeyi</strong> ciddi olarak düşünmelisiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6da0b14e7a68" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>