<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.4.1">Jekyll</generator><link href="https://program.sonsuz.us/feed.xml" rel="self" type="application/atom+xml" /><link href="https://program.sonsuz.us/" rel="alternate" type="text/html" /><updated>2026-10-31T06:05:43+00:00</updated><id>https://program.sonsuz.us/feed.xml</id><title type="html">SonsuzUs</title><subtitle>Programlama ve Yazılım</subtitle><author><name>Sonsuz Us</name></author><entry><title type="html">C# Sınıflar, Nesneler ve Metotlar: ref ve out ile Nesne Modelini Anlamak</title><link href="https://program.sonsuz.us/posts/c-siniflar-nesneler-ve-metotlar-ref-ve-out-ile-nesne-modelini-anlamak/" rel="alternate" type="text/html" title="C# Sınıflar, Nesneler ve Metotlar: ref ve out ile Nesne Modelini Anlamak" /><published>2026-10-31T00:00:00+00:00</published><updated>2026-10-31T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/c-siniflar-nesneler-ve-metotlar-ref-ve-out-ile-nesne-modelini-anlamak</id><content type="html" xml:base="https://program.sonsuz.us/posts/c-siniflar-nesneler-ve-metotlar-ref-ve-out-ile-nesne-modelini-anlamak/"><![CDATA[<p><img src="/img/c-siniflar-nesneler-62.svg" alt="c-siniflar-nesneler-62" /></p>

<p>Bir banka hesabını programlamak istediğinizi düşünün: hesabın bakiyesi vardır, para çekilebilir ve işlemin sonucu öğrenilebilir. C# bu dünyayı sınıflar, nesneler ve metotlarla temsil eder. İşin eğlenceli kısmı, aynı hesaba iki farklı değişkenle ulaşabilmenizdir. Ancak bir nesneyi değiştirmekle, değişkenin gösterdiği nesneyi değiştirmek aynı şey değildir!</p>

<p>``</p>

<h2 id="sınıf-plan-nesne-çalışan-örnektir">Sınıf plan, nesne çalışan örnektir</h2>

<p><strong>Sınıf</strong>, verileri ve davranışları bir araya getiren tür tanımıdır. <strong>Nesne</strong>, bu sınıftan oluşturulan somut örnektir. <strong>Metot</strong> ise bir nesnenin gerçekleştirebildiği işlemi tanımlar; ayrıca sınıfa ait statik metotlar da bulunabilir.</p>

<p>Bir sınıftan oluşturulan iki nesnenin bakiyeleri birbirinden bağımsız olabilir. Buna karşılık iki değişken aynı nesneye bağlanabilir. Aynı televizyonu yöneten iki kumanda düşünün: kumandalar farklıdır, fakat değiştirilen televizyon aynıdır.</p>

<table>
  <thead>
    <tr>
      <th>Kavram</th>
      <th>Banka örneği</th>
      <th>Görevi</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Sınıf</td>
      <td><code class="language-plaintext highlighter-rouge">Hesap</code></td>
      <td>Yapıyı ve davranışları tanımlar</td>
    </tr>
    <tr>
      <td>Nesne</td>
      <td>Oluşturulan müşteri hesabı</td>
      <td>Durumu taşır</td>
    </tr>
    <tr>
      <td>Özellik</td>
      <td><code class="language-plaintext highlighter-rouge">Bakiye</code></td>
      <td>Veriye kontrollü erişim sağlar</td>
    </tr>
    <tr>
      <td>Metot</td>
      <td><code class="language-plaintext highlighter-rouge">ParaCek</code></td>
      <td>İşlem gerçekleştirir</td>
    </tr>
  </tbody>
</table>

<p>C# sınıfları <strong>referans türüdür</strong>. Bir sınıf değişkeninin değeri, nesnenin kendisi değil, ona erişmeyi sağlayan referanstır. Referansı kopyalamak, nesneyi çoğaltmaz.</p>

<h2 id="durumu-davranışla-korumak">Durumu davranışla korumak</h2>

<p>Aşağıdaki sınıf, bakiyenin dışarıdan doğrudan değiştirilmesini engeller. Kurucu metot başlangıç durumunu oluşturur; <code class="language-plaintext highlighter-rouge">ParaCek</code> ise çekim kurallarını uygular ve sonucu bildirir.</p>

<div class="language-csharp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">using</span> <span class="nn">System</span><span class="p">;</span>

<span class="k">public</span> <span class="k">class</span> <span class="nc">Hesap</span>
<span class="p">{</span>
    <span class="k">public</span> <span class="kt">decimal</span> <span class="n">Bakiye</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>

    <span class="k">public</span> <span class="nf">Hesap</span><span class="p">(</span><span class="kt">decimal</span> <span class="n">bakiye</span><span class="p">)</span>
    <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">bakiye</span> <span class="p">&lt;</span> <span class="m">0</span><span class="p">)</span>
            <span class="k">throw</span> <span class="k">new</span> <span class="nf">ArgumentOutOfRangeException</span><span class="p">(</span><span class="k">nameof</span><span class="p">(</span><span class="n">bakiye</span><span class="p">));</span>

        <span class="n">Bakiye</span> <span class="p">=</span> <span class="n">bakiye</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="k">public</span> <span class="kt">bool</span> <span class="nf">ParaCek</span><span class="p">(</span><span class="kt">decimal</span> <span class="n">tutar</span><span class="p">,</span> <span class="k">out</span> <span class="kt">decimal</span> <span class="n">kalan</span><span class="p">)</span>
    <span class="p">{</span>
        <span class="n">kalan</span> <span class="p">=</span> <span class="n">Bakiye</span><span class="p">;</span>

        <span class="k">if</span> <span class="p">(</span><span class="n">tutar</span> <span class="p">&lt;=</span> <span class="m">0</span> <span class="p">||</span> <span class="n">tutar</span> <span class="p">&gt;</span> <span class="n">Bakiye</span><span class="p">)</span>
            <span class="k">return</span> <span class="k">false</span><span class="p">;</span>

        <span class="n">Bakiye</span> <span class="p">-=</span> <span class="n">tutar</span><span class="p">;</span>
        <span class="n">kalan</span> <span class="p">=</span> <span class="n">Bakiye</span><span class="p">;</span>
        <span class="k">return</span> <span class="k">true</span><span class="p">;</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">private set</code>, bakiyenin yalnızca sınıf içinden atanabilmesini sağlar. Bu yaklaşım <strong>kapsülleme</strong> olarak adlandırılır: veriyi saklamaktan çok, geçerli durumları korumak önemlidir. Negatif başlangıç bakiyesi reddedilir; geçersiz çekim ise hesabı değiştirmez.</p>

<p>Başarılı çekimin matematiksel modeli şöyledir:</p>

\[B_{son} = B_{ilk} - T\]

<p>Burada $T$ çekilen tutardır; işlemin kabul koşulu $0 &lt; T \leq B_{ilk}$ şeklindedir. Kod, bu koşulu denetleyerek nesnenin tutarlılığını korur. Para hesaplarında <code class="language-plaintext highlighter-rouge">decimal</code>, ondalık değerleri temsil etmek için genellikle <code class="language-plaintext highlighter-rouge">double</code> türünden daha uygundur.</p>

<h2 id="varsayılan-aktarım-ref-ve-out">Varsayılan aktarım, ref ve out</h2>

<p>C# parametreleri varsayılan olarak <strong>değer ile</strong> aktarır. <code class="language-plaintext highlighter-rouge">decimal</code> parametresinde sayısal değer kopyalanır. <code class="language-plaintext highlighter-rouge">Hesap</code> parametresinde ise referansın değeri kopyalanır. Bu yüzden normal bir parametre üzerinden nesnenin özelliklerini değiştirmek mümkündür; bunun için <code class="language-plaintext highlighter-rouge">ref</code> gerekmez.</p>

<p>Ancak metot içinde normal parametreye <code class="language-plaintext highlighter-rouge">new Hesap(...)</code> atamak, çağıranın değişkenini başka nesneye yönlendirmez. Yalnızca parametrenin yerel kopyası değişir. İşte <code class="language-plaintext highlighter-rouge">ref</code>, çağıranın değişkenine erişim sağlayarak bu ayrımı görünür kılar.</p>

<table>
  <thead>
    <tr>
      <th>Aktarım</th>
      <th>Çağrıdan önce değer gerekli mi?</th>
      <th>Metodun atama zorunluluğu</th>
      <th>Amaç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Normal</td>
      <td>Evet</td>
      <td>Yok</td>
      <td>Değerin kopyasıyla çalışmak</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">ref</code></td>
      <td>Evet</td>
      <td>Yok</td>
      <td>Mevcut değişkeni okuyup değiştirmek</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">out</code></td>
      <td>Hayır</td>
      <td>Her normal dönüş yolunda var</td>
      <td>Sonuç üretmek</td>
    </tr>
  </tbody>
</table>

<p><code class="language-plaintext highlighter-rouge">ref</code> ve <code class="language-plaintext highlighter-rouge">out</code>, hem metot bildiriminde hem çağrıda belirtilir. <code class="language-plaintext highlighter-rouge">out</code> parametresi, metot içinde okunmadan önce atanmalıdır. Örneğimizde <code class="language-plaintext highlighter-rouge">kalan</code> başlangıçta atanır; böylece başarısız çekimde bile kullanılabilir bir sonuç döner.</p>

<h2 id="referansı-değiştirmek-başka-bir-iştir">Referansı değiştirmek başka bir iştir</h2>

<p>.NET 6+ konsol projesinde aşağıdaki üst düzey kullanım kodunu sınıf bildiriminden önce yerleştirebilirsiniz:</p>

<div class="language-csharp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">var</span> <span class="n">hesap</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Hesap</span><span class="p">(</span><span class="m">100m</span><span class="p">);</span>
<span class="kt">var</span> <span class="n">ortak</span> <span class="p">=</span> <span class="n">hesap</span><span class="p">;</span>

<span class="kt">bool</span> <span class="n">basarili</span> <span class="p">=</span> <span class="n">hesap</span><span class="p">.</span><span class="nf">ParaCek</span><span class="p">(</span><span class="m">30m</span><span class="p">,</span> <span class="k">out</span> <span class="kt">decimal</span> <span class="n">kalan</span><span class="p">);</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"Başarılı: </span><span class="p">{</span><span class="n">basarili</span><span class="p">}</span><span class="s">, kalan: </span><span class="p">{</span><span class="n">kalan</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>

<span class="n">ortak</span><span class="p">.</span><span class="nf">ParaCek</span><span class="p">(</span><span class="m">10m</span><span class="p">,</span> <span class="k">out</span> <span class="n">kalan</span><span class="p">);</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="n">hesap</span><span class="p">.</span><span class="n">Bakiye</span><span class="p">);</span> <span class="c1">// 60</span>

<span class="nf">Yenile</span><span class="p">(</span><span class="k">ref</span> <span class="n">hesap</span><span class="p">);</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="n">hesap</span><span class="p">.</span><span class="n">Bakiye</span><span class="p">);</span> <span class="c1">// 0</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="n">ortak</span><span class="p">.</span><span class="n">Bakiye</span><span class="p">);</span> <span class="c1">// 60</span>

<span class="k">static</span> <span class="k">void</span> <span class="nf">Yenile</span><span class="p">(</span><span class="k">ref</span> <span class="n">Hesap</span> <span class="n">hedef</span><span class="p">)</span>
<span class="p">{</span>
    <span class="n">hedef</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Hesap</span><span class="p">(</span><span class="m">0m</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>İlk atamada <code class="language-plaintext highlighter-rouge">ortak</code> ve <code class="language-plaintext highlighter-rouge">hesap</code> aynı nesneyi gösterir. Dolayısıyla <code class="language-plaintext highlighter-rouge">ortak</code> üzerinden yapılan çekim, <code class="language-plaintext highlighter-rouge">hesap</code> üzerinden görülen bakiyeyi de değiştirir. <code class="language-plaintext highlighter-rouge">Yenile</code> ise <code class="language-plaintext highlighter-rouge">ref</code> sayesinde doğrudan <code class="language-plaintext highlighter-rouge">hesap</code> değişkeninin referansını değiştirir. <code class="language-plaintext highlighter-rouge">ortak</code>, eski nesneyi göstermeyi sürdürür; nesne topluca sıfırlanmamıştır.</p>

<h2 id="küçük-bir-seçim-rehberi">Küçük bir seçim rehberi</h2>

<p>Tek sonuç için çoğunlukla dönüş değerini kullanın. Başarı bilgisiyle ek sonuç gerekiyorsa <code class="language-plaintext highlighter-rouge">out</code> kullanışlıdır; <code class="language-plaintext highlighter-rouge">int.TryParse</code> bunun klasik örneğidir. Çağıranın mevcut değişkenini değiştirmek gerekiyorsa <code class="language-plaintext highlighter-rouge">ref</code> düşünülebilir. Son kontrol sorunuz şu olsun: “Nesnenin durumunu mu, değişkenin değerini mi değiştiriyorum?” Bu ayrım, referans karmaşasının büyük bölümünü çözer.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="csharp" /><category term="nesne-yönelimli-programlama" /><category term="sınıflar" /><category term="nesneler" /><category term="metotlar" /><category term="ref" /><category term="out" /><summary type="html"><![CDATA[Bir banka hesabını programlamak istediğinizi düşünün: hesabın bakiyesi vardır, para çekilebilir ve işlemin sonucu öğrenilebilir. C# bu dünyayı sınıflar, nesneler ve metotlarla temsil eder. İşin eğlenceli kısmı, aynı hesaba iki farklı değişkenle ulaşabilmenizdir. Ancak bir nesneyi değiştirmekle, değişkenin gösterdiği nesneyi değiştirmek aynı şey değildir!]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/c-siniflar-nesneler-62.png" /><media:content medium="image" url="https://program.sonsuz.us/img/c-siniflar-nesneler-62.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Ev Sessizleşince: Hareket Sensörleriyle Günlük Rutinlerdeki Sapmaları Yakalamak</title><link href="https://program.sonsuz.us/posts/ev-sessizlesince-hareket-sensorleriyle-gunluk-rutinlerdeki-sapmalari-yakalamak/" rel="alternate" type="text/html" title="Ev Sessizleşince: Hareket Sensörleriyle Günlük Rutinlerdeki Sapmaları Yakalamak" /><published>2026-10-31T00:00:00+00:00</published><updated>2026-10-31T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/ev-sessizlesince-hareket-sensorleriyle-gunluk-rutinlerdeki-sapmalari-yakalamak</id><content type="html" xml:base="https://program.sonsuz.us/posts/ev-sessizlesince-hareket-sensorleriyle-gunluk-rutinlerdeki-sapmalari-yakalamak/"><![CDATA[<p><img src="/img/ev-sessizlesince-hareket-72.svg" alt="ev-sessizlesince-hareket-72" /></p>

<p>Sabah mutfakta başlayan hareketlilik, öğleden sonra salona taşınan sakinlik… Evlerin de kendine özgü bir ritmi vardır. Hareket sensörleri, bu ritimdeki beklenmedik değişiklikleri görünür kılabilir. Ama amaç eve dijital bir Sherlock yerleştirmek değil; yaşlı veya yalnız yaşayan bireylerin bağımsızlığını korurken, gerektiğinde iletişim kurulmasını destekleyen, mahremiyete saygılı bir yardımcı geliştirmektir.
``</p>

<h2 id="sensör-gerçekten-neyi-bilir">Sensör gerçekten neyi bilir?</h2>

<p>Yaygın PIR sensörleri, görüş alanlarındaki kızılötesi değişimlerden hareket çıkarır. Birinin kim olduğunu, ne yaptığını veya sağlık durumunu doğrudan söylemezler. Dolayısıyla “hareket yok” ile “kişi tehlikede” aynı anlama gelmez: Uyku, dışarı çıkma, kitap okuma veya bağlantı arızası benzer kayıtlar oluşturabilir.</p>

<p>Temel veri akışı şöyledir: Sensör olayı, zaman damgası ve oda bilgisi yerel bir ağ geçidine ulaşır; ardından analiz için özetlenir. Saatlerin eşitlenmesi ve yinelenen kayıtların temizlenmesi önemlidir. Olay kaydı göndermeyen cihazın çalıştığını anlayabilmek için ayrıca düzenli durum mesajları gerekir. Aksi hâlde arızalı sensör, sessiz bir ev gibi görünür.</p>

<h2 id="ham-olaylardan-anlamlı-özelliklere">Ham olaylardan anlamlı özelliklere</h2>

<p>Sensörün yeniden tetikleme süresi, olay sayısını etkiler. Bu nedenle yalnızca tetikleme sayısını karşılaştırmak yanıltıcıdır. Daha dengeli bir özellik, otuz dakikalık pencerede hareket görülen farklı dakikaların sayısıdır. Bütün odaların kayıtları birleştirilir; aynı dakika iki odada hareket varsa toplamda bir kez sayılır.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>Ne anlatır?</th>
      <th>Tek başına neden yetmez?</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Hareketli dakika</td>
      <td>Genel etkinlik düzeyi</td>
      <td>Dışarı çıkmak da azaltır</td>
    </tr>
    <tr>
      <td>Hareketsizlik süresi</td>
      <td>Uzun sessizlik dönemleri</td>
      <td>Uyku sırasında normaldir</td>
    </tr>
    <tr>
      <td>Odalar arası geçiş</td>
      <td>Ev içindeki hareketlilik</td>
      <td>Misafirler örüntüyü değiştirir</td>
    </tr>
    <tr>
      <td>Cihaz durum mesajı</td>
      <td>Veri akışının sağlığı</td>
      <td>İnsan davranışını ölçmez</td>
    </tr>
  </tbody>
</table>

<p>İlk üç veya dört hafta, kişinin kendi referansını oluşturmak için kullanılabilir. Hafta içi ve hafta sonu ayrı değerlendirilmelidir. Karşılaştırma başka insanların ortalamasıyla değil, aynı kişinin benzer zaman dilimlerindeki geçmişiyle yapılır.</p>

<h2 id="normalden-uzaklığı-ölçmek">Normalden uzaklığı ölçmek</h2>

<p>Başlangıç için karmaşık bir sinir ağı şart değildir. Medyan, sıra dışı günlerden ortalamaya göre daha az etkilenir. Yayılımı ölçen medyan mutlak sapma ise $MAD = \operatorname{medyan}(\vert x_i-m\vert )$ şeklinde hesaplanır; burada $m$, geçmiş değerlerin medyanıdır.</p>

<p>Azalan etkinlik için kullanılabilecek sağlamlaştırılmış skor:</p>

\[z_t = \frac{m-x_t}{\max(1,\;1.4826\cdot MAD)}\]

<p>Burada $x_t$, güncel penceredeki hareketli dakika sayısıdır. Paydadaki 1, bir dakikalık alt sınırdır; geçmiş değerler aynı olduğunda sıfıra bölmeyi önler. Büyük pozitif skor, beklenenden düşük etkinlik gösterir. Örneğin medyan 18, MAD 3 ve güncel değer 2 olduğunda skor yaklaşık 3,6 olur. Ancak 3 gibi bir eşik yalnızca başlangıç tercihidir; klinik olarak doğrulanmış bir sınır değildir.</p>

<h2 id="python-ile-aday-sapmaları-çıkaralım">Python ile aday sapmaları çıkaralım</h2>

<p>Aşağıdaki kod, geçmiş özetlerden profil oluşturur ve güncel pencereleri karşılaştırır. <code class="language-plaintext highlighter-rouge">dilim</code>, gün içindeki otuz dakikalık zaman aralığını temsil eder. Güncel kayıtların geçmiş eğitim verisine katılmaması önemlidir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">pandas</span> <span class="k">as</span> <span class="n">pd</span>

<span class="n">anahtar</span> <span class="o">=</span> <span class="p">[</span><span class="sh">'</span><span class="s">gun_tipi</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">dilim</span><span class="sh">'</span><span class="p">]</span>
<span class="n">grup</span> <span class="o">=</span> <span class="n">gecmis</span><span class="p">.</span><span class="nf">groupby</span><span class="p">(</span><span class="n">anahtar</span><span class="p">)[</span><span class="sh">'</span><span class="s">aktif_dakika</span><span class="sh">'</span><span class="p">]</span>

<span class="n">profil</span> <span class="o">=</span> <span class="n">grup</span><span class="p">.</span><span class="nf">agg</span><span class="p">(</span><span class="n">merkez</span><span class="o">=</span><span class="sh">'</span><span class="s">median</span><span class="sh">'</span><span class="p">,</span> <span class="n">ornek</span><span class="o">=</span><span class="sh">'</span><span class="s">count</span><span class="sh">'</span><span class="p">)</span>
<span class="n">profil</span><span class="p">[</span><span class="sh">'</span><span class="s">mad</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="n">grup</span><span class="p">.</span><span class="nf">apply</span><span class="p">(</span>
    <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span><span class="n">s</span> <span class="o">-</span> <span class="n">s</span><span class="p">.</span><span class="nf">median</span><span class="p">()).</span><span class="nf">abs</span><span class="p">().</span><span class="nf">median</span><span class="p">()</span>
<span class="p">)</span>
<span class="n">profil</span><span class="p">[</span><span class="sh">'</span><span class="s">olcek</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="mf">1.4826</span> <span class="o">*</span> <span class="n">profil</span><span class="p">[</span><span class="sh">'</span><span class="s">mad</span><span class="sh">'</span><span class="p">]).</span><span class="nf">clip</span><span class="p">(</span><span class="n">lower</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

<span class="n">sonuc</span> <span class="o">=</span> <span class="n">guncel</span><span class="p">.</span><span class="nf">merge</span><span class="p">(</span>
    <span class="n">profil</span><span class="p">.</span><span class="nf">reset_index</span><span class="p">(),</span>
    <span class="n">on</span><span class="o">=</span><span class="n">anahtar</span><span class="p">,</span>
    <span class="n">how</span><span class="o">=</span><span class="sh">'</span><span class="s">left</span><span class="sh">'</span><span class="p">,</span>
    <span class="n">validate</span><span class="o">=</span><span class="sh">'</span><span class="s">many_to_one</span><span class="sh">'</span>
<span class="p">)</span>
<span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">puan</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span>
    <span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">merkez</span><span class="sh">'</span><span class="p">]</span> <span class="o">-</span> <span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">aktif_dakika</span><span class="sh">'</span><span class="p">]</span>
<span class="p">)</span> <span class="o">/</span> <span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">olcek</span><span class="sh">'</span><span class="p">]</span>

<span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">aday</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span>
    <span class="p">(</span><span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">puan</span><span class="sh">'</span><span class="p">]</span> <span class="o">&gt;</span> <span class="mi">3</span><span class="p">)</span>
    <span class="o">&amp;</span> <span class="p">(</span><span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">ornek</span><span class="sh">'</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="mi">6</span><span class="p">)</span>
    <span class="o">&amp;</span> <span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">sensorler_cevrimici</span><span class="sh">'</span><span class="p">]</span>
    <span class="o">&amp;</span> <span class="n">sonuc</span><span class="p">[</span><span class="sh">'</span><span class="s">evde_olmasi_bekleniyor</span><span class="sh">'</span><span class="p">]</span>
<span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">gecmis</code> ve <code class="language-plaintext highlighter-rouge">guncel</code>, önceden hazırlanmış DataFrame tablolarıdır. Çıktı acil durum kararı değil, inceleme adayıdır. Evde bulunma beklentisi, yalnızca hareket yokluğundan çıkarılmamalı; kişinin belirttiği program gibi izinli bağlamlarla desteklenmelidir.</p>

<h2 id="alarm-değil-kontrollü-iletişim">Alarm değil, kontrollü iletişim</h2>

<p>Tek pencere yerine ardışık pencerelerdeki sapmalar değerlendirilebilir. Ancak beklemek acil durumları geciktirebileceğinden, bu sistem tıbbi alarmın yerine geçmez. Bildirim politikası kişiyle birlikte belirlenmeli; önce nazik bir kontrol mesajı, gerekiyorsa yetkilendirilmiş yakına bildirim düşünülmelidir.</p>

<p>Başarıyı yalnızca doğrulukla ölçmeyin. Haftalık yanlış bildirim sayısı, tespit gecikmesi ve gözden kaçan olaylar da izlenmelidir. Tatiller veya kalıcı rutin değişiklikleri sonrasında profil kontrollü biçimde güncellenmelidir.</p>

<p>Son olarak, açık rıza, bildirimleri durdurabilme, sınırlı saklama süresi ve erişim kontrolü tasarımın temelidir. Mümkünse ham verileri evde tutup yalnızca gerekli özetleri paylaşın. İyi sistem, her sessizliği felaket sayan değil; belirsizliğini kabul edip insan iletişimini destekleyen sistemdir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="iot" /><category term="python" /><category term="anomali tespiti" /><category term="hareket sensörleri" /><category term="veri analizi" /><category term="yaşlı bakımı" /><summary type="html"><![CDATA[Sabah mutfakta başlayan hareketlilik, öğleden sonra salona taşınan sakinlik… Evlerin de kendine özgü bir ritmi vardır. Hareket sensörleri, bu ritimdeki beklenmedik değişiklikleri görünür kılabilir. Ama amaç eve dijital bir Sherlock yerleştirmek değil; yaşlı veya yalnız yaşayan bireylerin bağımsızlığını korurken, gerektiğinde iletişim kurulmasını destekleyen, mahremiyete saygılı bir yardımcı geliştirmektir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/ev-sessizlesince-hareket-72.png" /><media:content medium="image" url="https://program.sonsuz.us/img/ev-sessizlesince-hareket-72.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Monte Carlo ile Finansal Risk: Bilgisayarda Binlerce Olası Gelecek</title><link href="https://program.sonsuz.us/posts/monte-carlo-ile-finansal-risk-bilgisayarda-binlerce-olasi-gelecek/" rel="alternate" type="text/html" title="Monte Carlo ile Finansal Risk: Bilgisayarda Binlerce Olası Gelecek" /><published>2026-10-31T00:00:00+00:00</published><updated>2026-10-31T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/monte-carlo-ile-finansal-risk-bilgisayarda-binlerce-olasi-gelecek</id><content type="html" xml:base="https://program.sonsuz.us/posts/monte-carlo-ile-finansal-risk-bilgisayarda-binlerce-olasi-gelecek/"><![CDATA[<p>Yarın piyasa yükselir mi, düşer mi? Tek bir tahmin üretmek yerine yüz bin farklı yarın hayal ettiğinizi düşünün. Monte Carlo simülasyonu tam olarak bunu yapar: Belirsizliği rastgele örneklerle temsil eder, olası sonuçları hesaplar ve riskin dağılımını görünür kılar. Elimizde kristal küre yoktur; fakat oldukça çalışkan bir bilgisayar vardır.</p>

<p><img src="/img/monte-carlo-ile-24.svg" alt="monte-carlo-ile-24" /></p>

<p>``</p>

<h2 id="rastgelelik-neden-işe-yarıyor">Rastgelelik neden işe yarıyor?</h2>

<p>Monte Carlo’nun temel fikri, hesaplanması zor bir dağılımı çok sayıda örnekle yaklaşık olarak keşfetmektir. Her senaryo, seçtiğimiz modelin ürettiği olası bir gelecektir. Senaryoların sonunda portföy değerlerini sıralayarak kayıpların ne kadar büyük olabileceğini inceleriz.</p>

<p>Buradaki kritik ayrım şudur: <strong>Rastgele sayı üretmek, doğru piyasa modeli kurmakla aynı şey değildir.</strong> Yanlış varsayımlardan üretilen milyonlarca senaryo, yalnızca yanlışlığı daha hassas hesaplar.</p>

<p>Basit bir başlangıç modeli geometrik Brown hareketidir. Bu modelde gelecekteki fiyat şöyle yazılır:</p>

\[S_T=S_0 e^{(\mu-\sigma^2/2)T+\sigma\sqrt{T}Z},\qquad Z\sim\mathcal{N}(0,1).\]

<p>Burada $S_0$ başlangıç fiyatı, $\mu$ yıllık beklenen getiri parametresi, $\sigma$ yıllık volatilite, $T$ ise yıl cinsinden süredir. Normal dağılımlı değişken fiyatın kendisini değil, logaritmik getirisini etkiler; böylece fiyatlar pozitif kalır.</p>

<p>Bu yaklaşım anlaşılırdır, ancak sabit volatilite ve normal logaritmik getiriler gibi güçlü varsayımlar taşır. Gerçek piyasalardaki sıçramaları ve kalın kuyrukları eksik temsil edebilir.</p>

<h2 id="i̇ki-varlıkla-küçük-bir-risk-laboratuvarı">İki varlıkla küçük bir risk laboratuvarı</h2>

<p>Bir milyon liralık portföyün yüzde 60’ını birinci, yüzde 40’ını ikinci varlığa ayıralım. Ufkumuz on işlem günü olsun. İki varlık tamamen bağımsız hareket etmediği için korelasyonu da modele eklemeliyiz.</p>

<p>Aşağıdaki NumPy kodu, Cholesky ayrıştırmasıyla ilişkili normal örnekler üretir. Ardından her senaryoda dönem sonu portföy değerini ve kaybı hesaplar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>

<span class="n">rng</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">random</span><span class="p">.</span><span class="nf">default_rng</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
<span class="n">n</span> <span class="o">=</span> <span class="mi">100_000</span>
<span class="n">T</span> <span class="o">=</span> <span class="mi">10</span> <span class="o">/</span> <span class="mi">252</span>
<span class="n">initial</span> <span class="o">=</span> <span class="mi">1_000_000</span>
<span class="n">weights</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([</span><span class="mf">0.60</span><span class="p">,</span> <span class="mf">0.40</span><span class="p">])</span>
<span class="n">mu</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([</span><span class="mf">0.08</span><span class="p">,</span> <span class="mf">0.10</span><span class="p">])</span>
<span class="n">sigma</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([</span><span class="mf">0.20</span><span class="p">,</span> <span class="mf">0.30</span><span class="p">])</span>
<span class="n">corr</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([[</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">0.4</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.4</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">]])</span>

<span class="n">chol</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">cholesky</span><span class="p">(</span><span class="n">corr</span><span class="p">)</span>
<span class="n">z</span> <span class="o">=</span> <span class="n">rng</span><span class="p">.</span><span class="nf">standard_normal</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span> <span class="o">@</span> <span class="n">chol</span><span class="p">.</span><span class="n">T</span>

<span class="n">multipliers</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">exp</span><span class="p">(</span>
    <span class="p">(</span><span class="n">mu</span> <span class="o">-</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="n">sigma</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="o">*</span> <span class="n">T</span>
    <span class="o">+</span> <span class="n">sigma</span> <span class="o">*</span> <span class="n">np</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="n">T</span><span class="p">)</span> <span class="o">*</span> <span class="n">z</span>
<span class="p">)</span>
<span class="n">terminal_values</span> <span class="o">=</span> <span class="n">initial</span> <span class="o">*</span> <span class="p">(</span><span class="n">multipliers</span> <span class="o">@</span> <span class="n">weights</span><span class="p">)</span>
<span class="n">losses</span> <span class="o">=</span> <span class="n">initial</span> <span class="o">-</span> <span class="n">terminal_values</span>

<span class="n">var99</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">quantile</span><span class="p">(</span><span class="n">losses</span><span class="p">,</span> <span class="mf">0.99</span><span class="p">)</span>
<span class="n">es99</span> <span class="o">=</span> <span class="n">losses</span><span class="p">[</span><span class="n">losses</span> <span class="o">&gt;=</span> <span class="n">var99</span><span class="p">].</span><span class="nf">mean</span><span class="p">()</span>

<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">%99 VaR: </span><span class="si">{</span><span class="n">var99</span><span class="si">:</span><span class="p">,.</span><span class="mi">0</span><span class="n">f</span><span class="si">}</span><span class="s"> TL</span><span class="sh">"</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">%99 ES: </span><span class="si">{</span><span class="n">es99</span><span class="si">:</span><span class="p">,.</span><span class="mi">0</span><span class="n">f</span><span class="si">}</span><span class="s"> TL</span><span class="sh">"</span><span class="p">)</span>
</code></pre></div></div>

<p>Sabit tohum, sonuçların tekrar üretilebilmesini sağlar. Cholesky dönüşümü, bağımsız çekilişleri hedef korelasyona sahip şoklara dönüştürür. Kullanılan korelasyon matrisinin pozitif tanımlı olması gerekir.</p>

<p>Kod, başlangıçta alınan varlıkların elde tutulduğunu varsayar; günlük yeniden dengeleme yapmaz. Ayrıca bütün fiyat yollarını değil, doğrudan dönem sonunu örnekler. Bu model altında dönem sonu riski için yeterlidir; bariyer opsiyonları veya dönem içindeki maksimum kayıp gibi yola bağlı ölçüler için zaman adımları gerekir. Parametreler örnektir; yatırım önerisi değildir.</p>

<h2 id="var-ve-es-bize-ne-söylüyor">VaR ve ES bize ne söylüyor?</h2>

<p>Kaybı $L=V_0-V_T$ olarak tanımlıyoruz. Pozitif değer zarar, negatif değer kazanç demektir. Yüzde 99 VaR, kayıp dağılımının yüzde 99’luk kantilidir:</p>

\[\operatorname{VaR}_{0.99}(L)=q_{0.99}(L).\]

<p>Örneğin VaR 80 bin lira çıkarsa, modeldeki on günlük kayıpların yaklaşık yüzde 99’u bu eşiği aşmaz. Bu, kalan yüzde 1’de ne olacağını söylemez ve gerçek dünyaya verilmiş bir garanti değildir.</p>

<table>
  <thead>
    <tr>
      <th>Ölçü</th>
      <th>Yanıtladığı soru</th>
      <th>Sınırı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>VaR</td>
      <td>Kayıp eşiği nerede?</td>
      <td>Eşiğin ötesini özetlemez</td>
    </tr>
    <tr>
      <td>ES</td>
      <td>En kötü yüzde 1’de ortalama kayıp ne?</td>
      <td>Kuyruk modeline duyarlıdır</td>
    </tr>
    <tr>
      <td>Standart sapma</td>
      <td>Sonuçlar ne kadar dağınık?</td>
      <td>Kazanç ve kaybı birlikte ölçer</td>
    </tr>
  </tbody>
</table>

<p>Kodda ES, eşik üzerindeki kayıpların ortalamasıdır. Bu sürekli dağılım örneğinde, felaket mahallesinin ortalama faturasını gösterir.</p>

<h2 id="simülasyonu-gerçekçilikle-terbiye-etmek">Simülasyonu gerçekçilikle terbiye etmek</h2>

<p>Volatiliteyi geçmiş verilerden tahmin ederken veri sıklığını ve yıllıklaştırmayı tutarlı seçin. Buradaki $\mu$, gerçek dünya risk analizi içindir; opsiyon fiyatlamasındaki risksiz faiz parametresiyle otomatik olarak değiştirilmemelidir.</p>

<p>Korelasyonların krizlerde yükselebileceğini ayrıca sınayın. Volatiliteyi ikiye katlayıp korelasyonu 0.95 yaparak sonuçları karşılaştırmak, modelin hassasiyetini gösteren basit bir stres denemesidir; krizi eksiksiz temsil etmez.</p>

<p>Senaryo sayısını artırmak örnekleme hatasını azaltır. Düzenli koşullarda standart hatalar kabaca $1/\sqrt{N}$ ölçeğinde küçülür; fakat model hatası ortadan kalkmaz. Farklı tohumlarla tekrarlama, kuyruk örnek sayısını kontrol etme ve geçmiş gerçekleşmelerle geriye dönük sınama bu yüzden önemlidir.</p>

<p>Monte Carlo geleceği bilmez. Daha faydalı bir iş yapar: Varsayımlarınızın hangi geleceklerde canınızı yakabileceğini gösterir. Risk yönetimi de tam burada, güzel görünen ortalamaların arkasındaki tatsız sürprizleri sorgulayarak başlar.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="monte carlo" /><category term="finansal risk" /><category term="python" /><category term="simülasyon" /><category term="var" /><category term="olasılık" /><summary type="html"><![CDATA[Yarın piyasa yükselir mi, düşer mi? Tek bir tahmin üretmek yerine yüz bin farklı yarın hayal ettiğinizi düşünün. Monte Carlo simülasyonu tam olarak bunu yapar: Belirsizliği rastgele örneklerle temsil eder, olası sonuçları hesaplar ve riskin dağılımını görünür kılar. Elimizde kristal küre yoktur; fakat oldukça çalışkan bir bilgisayar vardır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/monte-carlo-ile-24.png" /><media:content medium="image" url="https://program.sonsuz.us/img/monte-carlo-ile-24.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Oyun İçi Ekonomiler: Altın Yağmuru Neden Enflasyona Dönüşür?</title><link href="https://program.sonsuz.us/posts/oyun-ici-ekonomiler-altin-yagmuru-neden-enflasyona-donusur/" rel="alternate" type="text/html" title="Oyun İçi Ekonomiler: Altın Yağmuru Neden Enflasyona Dönüşür?" /><published>2026-10-31T00:00:00+00:00</published><updated>2026-10-31T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/oyun-ici-ekonomiler-altin-yagmuru-neden-enflasyona-donusur</id><content type="html" xml:base="https://program.sonsuz.us/posts/oyun-ici-ekonomiler-altin-yagmuru-neden-enflasyona-donusur/"><![CDATA[<p>Bir ejderhayı kestiniz, sandıktan bin altın çıktı ve kendinizi zengin hissettiniz. Fakat pazardaki sıradan kılıç geçen hafta beş yüz altınken bugün iki bin altın! Tebrikler: Ejderhadan kurtuldunuz, enflasyona yakalandınız. Oyun içi ekonomiler, gerçek ekonominin bazı mekanizmalarını şaşırtıcı biçimde tekrarlar; üstelik merkez bankasının yerinde çoğunlukla birkaç geliştirici oturur.</p>

<p>``</p>

<h2 id="altın-çoğalınca-neden-herkes-zenginleşmez">Altın çoğalınca neden herkes zenginleşmez?</h2>

<p>Paranın değeri, yalnızca sahip olduğunuz miktardan değil, onunla satın alabildiğiniz şeylerden gelir. Oyuncuların cüzdanları büyürken ticarete konu olan ürünlerin miktarı aynı hızda artmıyorsa fiyatlar üzerinde yükseliş baskısı oluşabilir.</p>

<p>Bu ilişkiyi düşünmek için klasik miktar denklemi yararlıdır:</p>

\[MV = PY\]

<p>Burada $M$ para miktarı, $V$ paranın dolaşım hızı, $P$ fiyat düzeyi ve $Y$ işlem gören reel mal ve hizmet hacmidir. Denklem tek başına bir tahmin makinesi değildir. Oyuncular altını biriktirirse dolaşım yavaşlayabilir; üretim artarsa fiyat baskısı hafifleyebilir. Ayrıca yalnızca nadir bir kılıcın pahalanması, genel enflasyon anlamına gelmez.</p>

<h2 id="gerçek-ekonomiyle-akrabalık-ilişkisi">Gerçek ekonomiyle akrabalık ilişkisi</h2>

<table>
  <thead>
    <tr>
      <th>Mekanizma</th>
      <th>Gerçek ekonomi</th>
      <th>Oyun ekonomisi</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Para yaratımı</td>
      <td>Bankacılık ve para politikası</td>
      <td>Görev ödülleri, yaratık ganimetleri</td>
    </tr>
    <tr>
      <td>Üretim</td>
      <td>İş gücü ve üretim kapasitesi</td>
      <td>Toplama, üretim tarifleri, düşme oranları</td>
    </tr>
    <tr>
      <td>Para çıkışı</td>
      <td>Vergiler ve diğer mekanizmalar</td>
      <td>Sistemden silinen ücretler</td>
    </tr>
    <tr>
      <td>Beklentiler</td>
      <td>Gelecekteki fiyat beklentileri</td>
      <td>Güncelleme öncesi eşya stoklama</td>
    </tr>
    <tr>
      <td>Dış şoklar</td>
      <td>Tedarik kesintileri</td>
      <td>Açıklar, botlar, içerik güncellemeleri</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/oyun-ici-ekonomiler-38.svg" alt="oyun-ici-ekonomiler-38" /></p>

<p>Benzetmenin sınırı önemlidir: Gerçek hayatta vergilendirilen para yeniden harcanabilir. Oyunda ise bir onarım ücreti gerçekten siliniyorsa para arzını azaltır. Geliştirici ayrıca bir eşyanın bulunma ihtimalini tek satırla değiştirebilir; gerçek ekonomide bakır madenine böyle bir yama gönderemezsiniz.</p>

<h2 id="kaynaklar-ve-giderler-musluk-ile-lavabo">Kaynaklar ve giderler: Musluk ile lavabo</h2>

<p>Ekonomi tasarımında para yaratan mekanizmalara <strong>kaynak</strong>, parayı dolaşımdan kaldıran mekanizmalara <strong>gider</strong> denir. Basit bilanço şöyledir:</p>

\[M_{t+1} = M_t + F_t - S_t\]

<p>$F_t$ dönemde yaratılan, $S_t$ ise silinen paradır. Oyuncular arasındaki normal alışveriş parayı yok etmez; yalnızca sahibini değiştirir. Pazar komisyonu ancak sistem tarafından siliniyorsa gider sayılır.</p>

<p>Denge, her gün kaynaklarla giderleri eşitlemek değildir. Oyuncu sayısı ve üretim büyürken daha fazla para gerekebilir. Buna karşılık sınırsız tekrarlanabilen görevler, botlarla birleşince ekonomiye yangın hortumuyla altın püskürtebilir.</p>

<p>İyi giderler oyuncuya değer sunar: kozmetik seçenekler, isteğe bağlı hizmetler veya anlamlı üretim maliyetleri. Sürekli yükselen zorunlu onarım ücretleri ise ekonomiyi düzeltirken eğlenceyi bozabilir. Lavaboyu açmak için oyuncunun evini su altında bırakmayın.</p>

<h2 id="python-ile-küçük-bir-erken-uyarı-sistemi">Python ile küçük bir erken uyarı sistemi</h2>

<p>Aşağıdaki örnek, sabit bir referans sepetindeki piyasa fiyatlarını karşılaştırır. Ağırlıklar başlangıç dönemindeki harcama paylarını temsil eder. Fiyat artışı ve pozitif net para üretimi birlikte görülürse inceleme için küçük bir ödül ayarlaması önerilir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">BASE</span> <span class="o">=</span> <span class="p">{</span>
    <span class="sh">"</span><span class="s">iksir</span><span class="sh">"</span><span class="p">:</span> <span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mf">0.40</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">demir</span><span class="sh">"</span><span class="p">:</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mf">0.35</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">ekmek</span><span class="sh">"</span><span class="p">:</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">),</span>
<span class="p">}</span>


<span class="k">def</span> <span class="nf">economic_signal</span><span class="p">(</span><span class="n">prices</span><span class="p">,</span> <span class="n">net_flow</span><span class="p">):</span>
    <span class="k">if</span> <span class="nf">any</span><span class="p">(</span><span class="n">prices</span><span class="p">[</span><span class="n">item</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="mi">0</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">BASE</span><span class="p">):</span>
        <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Fiyatlar pozitif olmalı</span><span class="sh">"</span><span class="p">)</span>

    <span class="n">index</span> <span class="o">=</span> <span class="nf">sum</span><span class="p">(</span>
        <span class="n">weight</span> <span class="o">*</span> <span class="n">prices</span><span class="p">[</span><span class="n">item</span><span class="p">]</span> <span class="o">/</span> <span class="n">baseline</span>
        <span class="k">for</span> <span class="n">item</span><span class="p">,</span> <span class="p">(</span><span class="n">baseline</span><span class="p">,</span> <span class="n">weight</span><span class="p">)</span> <span class="ow">in</span> <span class="n">BASE</span><span class="p">.</span><span class="nf">items</span><span class="p">()</span>
    <span class="p">)</span>
    <span class="n">multiplier</span> <span class="o">=</span> <span class="mf">0.97</span> <span class="k">if</span> <span class="n">index</span> <span class="o">&gt;</span> <span class="mf">1.08</span> <span class="ow">and</span> <span class="n">net_flow</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="k">else</span> <span class="mf">1.0</span>
    <span class="k">return</span> <span class="p">{</span><span class="sh">"</span><span class="s">index</span><span class="sh">"</span><span class="p">:</span> <span class="nf">round</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="sh">"</span><span class="s">reward_multiplier</span><span class="sh">"</span><span class="p">:</span> <span class="n">multiplier</span><span class="p">}</span>


<span class="n">prices</span> <span class="o">=</span> <span class="p">{</span><span class="sh">"</span><span class="s">iksir</span><span class="sh">"</span><span class="p">:</span> <span class="mi">12</span><span class="p">,</span> <span class="sh">"</span><span class="s">demir</span><span class="sh">"</span><span class="p">:</span> <span class="mi">22</span><span class="p">,</span> <span class="sh">"</span><span class="s">ekmek</span><span class="sh">"</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
<span class="nf">print</span><span class="p">(</span><span class="nf">economic_signal</span><span class="p">(</span><span class="n">prices</span><span class="p">,</span> <span class="n">net_flow</span><span class="o">=</span><span class="mi">5000</span><span class="p">))</span>
</code></pre></div></div>

<p>Sonuçtaki <code class="language-plaintext highlighter-rouge">1.115</code>, referans sepete göre yüzde 11,5 fiyat artışıdır. Önerilen <code class="language-plaintext highlighter-rouge">0.97</code>, ödüllerde yüzde üç azaltma anlamına gelir. Ancak yüzde sekizlik eşik örnektir; bu kod otomatik merkez bankası değil, gösterge panelinin başlangıcıdır. Gerçek uygulamada eksik veri kontrolü ve yeterli işlem hacmi de gerekir.</p>

<h2 id="dengeyi-ölç-oyuncuyu-unutma">Dengeyi ölç, oyuncuyu unutma</h2>

<p>Tek günlük fiyatlara tepki vermek yerine haftalık eğilimleri, işlem hacmini ve manipülasyona dayanıklı fiyat istatistiklerini izleyin. Yeni başlayanlarla deneyimli oyuncuları ayrı değerlendirin: Ortalama servet artarken yeni oyuncunun ilk ekipmanına ulaşma süresi uzayabilir.</p>

<p>Birden fazla para birimi varsa her birinin kaynaklarını, giderlerini ve dönüşüm yollarını takip edin. Açıkları kapatmak çoğu zaman herkesten daha fazla ücret almaktan daha etkilidir. Değişiklikleri küçük uygulayın, sonuçlarını karşılaştırın ve gerekçelerini açıklayın.</p>

<p>Başarılı oyun ekonomisi, fiyatların sonsuza kadar sabit kaldığı ekonomi değildir. Oyuncunun emeğinin anlamlı kaldığı, ticaretin canlı olduğu ve yeni gelenlerin yarışa katılabildiği ekonomidir. Sonuçta amaç kusursuz bir hesap tablosu değil, yarın da giriş yapmak isteyeceğiniz bir dünyadır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="oyun tasarımı" /><category term="sanal ekonomi" /><category term="enflasyon" /><category term="ekonomi dengesi" /><category term="python" /><category term="oyun geliştirme" /><summary type="html"><![CDATA[Bir ejderhayı kestiniz, sandıktan bin altın çıktı ve kendinizi zengin hissettiniz. Fakat pazardaki sıradan kılıç geçen hafta beş yüz altınken bugün iki bin altın! Tebrikler: Ejderhadan kurtuldunuz, enflasyona yakalandınız. Oyun içi ekonomiler, gerçek ekonominin bazı mekanizmalarını şaşırtıcı biçimde tekrarlar; üstelik merkez bankasının yerinde çoğunlukla birkaç geliştirici oturur.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/oyun-ici-ekonomiler-38.png" /><media:content medium="image" url="https://program.sonsuz.us/img/oyun-ici-ekonomiler-38.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Roket Fırlatma Simülasyonları: Yakıt Azalırken Diferansiyel Denklemler Nasıl Uçar?</title><link href="https://program.sonsuz.us/posts/roket-firlatma-simulasyonlari-yakit-azalirken-diferansiyel-denklemler-nasil-ucar/" rel="alternate" type="text/html" title="Roket Fırlatma Simülasyonları: Yakıt Azalırken Diferansiyel Denklemler Nasıl Uçar?" /><published>2026-10-31T00:00:00+00:00</published><updated>2026-10-31T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/roket-firlatma-simulasyonlari-yakit-azalirken-diferansiyel-denklemler-nasil-ucar</id><content type="html" xml:base="https://program.sonsuz.us/posts/roket-firlatma-simulasyonlari-yakit-azalirken-diferansiyel-denklemler-nasil-ucar/"><![CDATA[<p>Bir roketi simüle etmek, ekrandaki bir nesnenin yüksekliğini sürekli artırmaktan çok daha heyecanlıdır. Yakıt tükendikçe kütle azalır, atmosfer inceldikçe sürükleme değişir ve motor sustuğunda yerçekimi sahneyi devralır. Bu değişkenlerin birlikte nasıl hareket ettiğini anlamak için diferansiyel denklemler kuracak, ardından Python ile sayısal olarak çözeceğiz. Emniyet kemerlerinizi matematiksel olarak bağlayın!</p>

<p>``</p>

<h2 id="önce-modelin-sınırlarını-çizelim">Önce modelin sınırlarını çizelim</h2>

<p>Dikey uçan, rüzgârdan etkilenmeyen ve yön değiştirmeyen bir roket düşünelim. Durum değişkenlerimiz yükseklik $h$, dikey hız $v$ ve toplam kütle $m$ olsun. Pozitif yön yukarıdır; başlangıçta roket yerde ve hareketsizdir. Yakıt dışında kütle kaybı olmadığını varsayıyoruz. Bu basitleştirmeler gerçek uçuşun bütün ayrıntılarını kapsamaz, ancak temel fiziği görünür kılar.</p>

<h2 id="yakıt-itki-ve-hareket-denklemleri">Yakıt, itki ve hareket denklemleri</h2>

<p>Motorun saniyede tükettiği yakıt miktarına $q$, etkin egzoz hızına $v_e$ diyelim. Motor çalışırken:</p>

\[\frac{dm}{dt}=-q,\qquad T=qv_e\]

<p>Buradaki $v_e$, egzozun rokete göre hızını ve seçilen modeldeki basınç katkısını temsil eden etkin değerdir. Sabit $q$ ve $v_e$ altında itki sabittir; fakat roket hafiflediği için aynı itkinin ürettiği ivme büyür. Gaz pedalını sabit tutup aracın yükünü azaltmak gibi!</p>

<p>Hareket denklemleri ise şöyledir:</p>

\[\frac{dh}{dt}=v,\qquad \frac{dv}{dt}=\frac{T-\frac12\rho(h)C_DA\,v\vert v\vert }{m}-g(h)\]

<p>$v\vert v\vert $ ifadesi önemlidir: Sürükleme yükselirken aşağı, düşerken yukarı yönelir. Değişken kütleli sistemde egzozun momentum etkisi zaten itkinin içindedir; ayrıca bir $v\,dm/dt$ terimi eklemek bu etkiyi yanlış biçimde tekrar sayar.</p>

<p>Atmosfer ve yerçekimi için basit ama kullanışlı iki yaklaşım seçebiliriz:</p>

\[\rho(h)=\rho_0e^{-h/H},\qquad g(h)=g_0\left(\frac{R}{R+h}\right)^2\]

<p>Burada $H$ atmosferin ölçek yüksekliği, $R$ Dünya yarıçapıdır. $C_D$ sürükleme katsayısı, $A$ ise referans kesit alanıdır. Gerçekte $C_D$ hızla değişebilir; şimdilik sabit kabul ediyoruz.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>Motor çalışırken</th>
      <th>Yakıt bittikten sonra</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Kütle değişimi</td>
      <td>$-q$</td>
      <td>Sıfır</td>
    </tr>
    <tr>
      <td>İtki</td>
      <td>$qv_e$</td>
      <td>Sıfır</td>
    </tr>
    <tr>
      <td>Sürükleme</td>
      <td>Harekete karşı</td>
      <td>Harekete karşı</td>
    </tr>
    <tr>
      <td>Yerçekimi</td>
      <td>Aşağı yönlü</td>
      <td>Aşağı yönlü</td>
    </tr>
  </tbody>
</table>

<h2 id="neden-sayısal-entegrasyon">Neden sayısal entegrasyon?</h2>

<p>Bu denklemler birbirine bağlıdır: Yükseklik yoğunluğu, yoğunluk sürüklemeyi, sürükleme de hızı değiştirir. Genel durumda tek bir kapalı formül aramak yerine zaman boyunca küçük ilerlemeler hesaplarız. Ancak küçük adım seçmek tek başına doğruluk garantisi değildir; yöntemin mertebesi ve hata kontrolü de belirleyicidir.</p>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Güçlü tarafı</th>
      <th>Dikkat edilmesi gereken</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>İleri Euler</td>
      <td>Kolay anlaşılır</td>
      <td>Büyük adımlarda ciddi hata</td>
    </tr>
    <tr>
      <td>RK4</td>
      <td>Düzgün problemlerde yüksek doğruluk</td>
      <td>Genellikle sabit adım</td>
    </tr>
    <tr>
      <td>Uyarlamalı RK45</td>
      <td>Yerel hataya göre adım seçer</td>
      <td>Toleranslar doğru belirlenmeli</td>
    </tr>
  </tbody>
</table>

<h2 id="python-ile-iki-aşamalı-uçuş">Python ile iki aşamalı uçuş</h2>

<p>Aşağıdaki örnek önce yanmayı, sonra motorsuz uçuşu çözer. Sabit tüketimde yanma süresi $(m_0-m_d)/q$ olduğundan aşamaları tam bu noktada ayırırız. Böylece motor kapanışındaki süreksizliği çözücüye açıkça bildiririz.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>
<span class="kn">from</span> <span class="n">scipy.integrate</span> <span class="kn">import</span> <span class="n">solve_ivp</span>

<span class="n">m0</span><span class="p">,</span> <span class="n">md</span> <span class="o">=</span> <span class="mf">500.0</span><span class="p">,</span> <span class="mf">300.0</span>  <span class="c1"># kg: toplam ve kuru kütle
</span><span class="n">q</span><span class="p">,</span> <span class="n">ve</span> <span class="o">=</span> <span class="mf">4.0</span><span class="p">,</span> <span class="mf">2200.0</span>    <span class="c1"># kg/s ve m/s
</span><span class="n">Cd</span><span class="p">,</span> <span class="n">A</span> <span class="o">=</span> <span class="mf">0.4</span><span class="p">,</span> <span class="mf">0.3</span>
<span class="n">rho0</span><span class="p">,</span> <span class="n">H</span> <span class="o">=</span> <span class="mf">1.225</span><span class="p">,</span> <span class="mf">8500.0</span>
<span class="n">R</span><span class="p">,</span> <span class="n">g0</span> <span class="o">=</span> <span class="mf">6.371e6</span><span class="p">,</span> <span class="mf">9.81</span>
<span class="n">burn_time</span> <span class="o">=</span> <span class="p">(</span><span class="n">m0</span> <span class="o">-</span> <span class="n">md</span><span class="p">)</span> <span class="o">/</span> <span class="n">q</span>

<span class="k">def</span> <span class="nf">dynamics</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">burning</span><span class="p">):</span>
    <span class="n">h</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">m</span> <span class="o">=</span> <span class="n">y</span>
    <span class="n">rho</span> <span class="o">=</span> <span class="n">rho0</span> <span class="o">*</span> <span class="n">np</span><span class="p">.</span><span class="nf">exp</span><span class="p">(</span><span class="o">-</span><span class="n">h</span> <span class="o">/</span> <span class="n">H</span><span class="p">)</span>
    <span class="n">gravity</span> <span class="o">=</span> <span class="n">g0</span> <span class="o">*</span> <span class="p">(</span><span class="n">R</span> <span class="o">/</span> <span class="p">(</span><span class="n">R</span> <span class="o">+</span> <span class="n">h</span><span class="p">))</span> <span class="o">**</span> <span class="mi">2</span>
    <span class="n">drag</span> <span class="o">=</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="n">rho</span> <span class="o">*</span> <span class="n">Cd</span> <span class="o">*</span> <span class="n">A</span> <span class="o">*</span> <span class="n">v</span> <span class="o">*</span> <span class="nf">abs</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
    <span class="n">thrust</span> <span class="o">=</span> <span class="n">q</span> <span class="o">*</span> <span class="n">ve</span> <span class="k">if</span> <span class="n">burning</span> <span class="k">else</span> <span class="mf">0.0</span>
    <span class="n">dm</span> <span class="o">=</span> <span class="o">-</span><span class="n">q</span> <span class="k">if</span> <span class="n">burning</span> <span class="k">else</span> <span class="mf">0.0</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">v</span><span class="p">,</span> <span class="p">(</span><span class="n">thrust</span> <span class="o">-</span> <span class="n">drag</span><span class="p">)</span> <span class="o">/</span> <span class="n">m</span> <span class="o">-</span> <span class="n">gravity</span><span class="p">,</span> <span class="n">dm</span><span class="p">]</span>

<span class="k">def</span> <span class="nf">ground</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">y</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>

<span class="n">ground</span><span class="p">.</span><span class="n">terminal</span> <span class="o">=</span> <span class="bp">True</span>
<span class="n">ground</span><span class="p">.</span><span class="n">direction</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">options</span> <span class="o">=</span> <span class="nf">dict</span><span class="p">(</span><span class="n">rtol</span><span class="o">=</span><span class="mf">1e-7</span><span class="p">,</span> <span class="n">atol</span><span class="o">=</span><span class="p">[</span><span class="mf">1e-3</span><span class="p">,</span> <span class="mf">1e-4</span><span class="p">,</span> <span class="mf">1e-6</span><span class="p">],</span>
               <span class="n">max_step</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>

<span class="n">powered</span> <span class="o">=</span> <span class="nf">solve_ivp</span><span class="p">(</span>
    <span class="k">lambda</span> <span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="nf">dynamics</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="bp">True</span><span class="p">),</span>
    <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">burn_time</span><span class="p">),</span> <span class="p">[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="n">m0</span><span class="p">],</span> <span class="o">**</span><span class="n">options</span>
<span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">powered</span><span class="p">.</span><span class="n">success</span><span class="p">:</span>
    <span class="k">raise</span> <span class="nc">RuntimeError</span><span class="p">(</span><span class="n">powered</span><span class="p">.</span><span class="n">message</span><span class="p">)</span>

<span class="n">state</span> <span class="o">=</span> <span class="n">powered</span><span class="p">.</span><span class="n">y</span><span class="p">[:,</span> <span class="o">-</span><span class="mi">1</span><span class="p">].</span><span class="nf">copy</span><span class="p">()</span>
<span class="n">state</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="n">md</span>  <span class="c1"># Yuvarlama farkını gider.
</span><span class="n">coast</span> <span class="o">=</span> <span class="nf">solve_ivp</span><span class="p">(</span>
    <span class="k">lambda</span> <span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="nf">dynamics</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="bp">False</span><span class="p">),</span>
    <span class="p">(</span><span class="n">burn_time</span><span class="p">,</span> <span class="mf">600.0</span><span class="p">),</span> <span class="n">state</span><span class="p">,</span> <span class="n">events</span><span class="o">=</span><span class="n">ground</span><span class="p">,</span> <span class="o">**</span><span class="n">options</span>
<span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">coast</span><span class="p">.</span><span class="n">success</span><span class="p">:</span>
    <span class="k">raise</span> <span class="nc">RuntimeError</span><span class="p">(</span><span class="n">coast</span><span class="p">.</span><span class="n">message</span><span class="p">)</span>
<span class="k">if</span> <span class="n">coast</span><span class="p">.</span><span class="n">t_events</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="n">size</span><span class="p">:</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">'</span><span class="s">Yere dönüş zamanı:</span><span class="sh">'</span><span class="p">,</span> <span class="n">coast</span><span class="p">.</span><span class="n">t_events</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">])</span>
<span class="k">else</span><span class="p">:</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">'</span><span class="s">600 saniye içinde yere dönüş gerçekleşmedi.</span><span class="sh">'</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">ground</code> olayı, yüksekliğin azalarak sıfırı geçmesini yakalar ve çözümü durdurur. Bileşenlere ayrı mutlak toleranslar vermemizin nedeni yükseklik, hız ve kütlenin farklı birimlere sahip olmasıdır. Seçilen başlangıç itkisinin ağırlıktan büyük olması da kalkışı mümkün kılar.</p>

<h2 id="sonuçlara-güvenmeden-önce">Sonuçlara güvenmeden önce</h2>

<p>Sürükleme ve yerçekimini kaldırarak çözümü roket denklemiyle karşılaştırın:</p>

\[\Delta v=v_e\ln\left(\frac{m_0}{m_d}\right)\]

<p>Ardından toleransları sıkılaştırıp sonuçların yakınsadığını kontrol edin. Kütlenin kuru kütlenin altına inmediğini doğrulayın. Bu model eğitim içindir; gerçek uçuş analizinde atmosfer verileri, değişken itki, yönelim ve yapısal sınırlar da gerekir. Roket bilimi zor olabilir, ama ilk sağlam adım doğru denklemdir!</p>

<p><img src="/img/roket-firlatma-simulasyonlari-10.svg" alt="roket-firlatma-simulasyonlari-10" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="sayısal entegrasyon" /><category term="roket simülasyonu" /><category term="diferansiyel denklemler" /><category term="python" /><category term="scipy" /><category term="fizik" /><summary type="html"><![CDATA[Bir roketi simüle etmek, ekrandaki bir nesnenin yüksekliğini sürekli artırmaktan çok daha heyecanlıdır. Yakıt tükendikçe kütle azalır, atmosfer inceldikçe sürükleme değişir ve motor sustuğunda yerçekimi sahneyi devralır. Bu değişkenlerin birlikte nasıl hareket ettiğini anlamak için diferansiyel denklemler kuracak, ardından Python ile sayısal olarak çözeceğiz. Emniyet kemerlerinizi matematiksel olarak bağlayın!]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/roket-firlatma-simulasyonlari-10.png" /><media:content medium="image" url="https://program.sonsuz.us/img/roket-firlatma-simulasyonlari-10.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Açık Veri Portalları: Şehir Verisi Vatandaşla Nasıl Buluşur?</title><link href="https://program.sonsuz.us/posts/acik-veri-portallari-sehir-verisi-vatandasla-nasil-bulusur/" rel="alternate" type="text/html" title="Açık Veri Portalları: Şehir Verisi Vatandaşla Nasıl Buluşur?" /><published>2026-10-30T00:00:00+00:00</published><updated>2026-10-30T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/acik-veri-portallari-sehir-verisi-vatandasla-nasil-bulusur</id><content type="html" xml:base="https://program.sonsuz.us/posts/acik-veri-portallari-sehir-verisi-vatandasla-nasil-bulusur/"><![CDATA[<p>Bir şehir her gün devasa miktarda veri üretir: otobüslerin konumu, hava kalitesi, yol çalışmaları, bütçe harcamaları, park doluluk oranları ve hatta hangi mahallede kaç ağaç bulunduğu… Belediyeler bu verileri yalnızca kurum içinde saklamak yerine açık veri portalları ve API’ler aracılığıyla paylaşabilir. Böylece vatandaşlar, araştırmacılar ve yazılımcılar şehrin dijital hazinesinden yararlanarak yeni uygulamalar geliştirebilir.</p>

<p><img src="/img/acik-veri-portallari-40.svg" alt="acik-veri-portallari-40" /></p>

<p>``</p>

<h2 id="açık-veri-nedir">Açık veri nedir?</h2>

<p>Açık veri; herkesin erişebildiği, kullanabildiği, değiştirebildiği ve uygun lisans koşullarıyla yeniden paylaşabildiği veridir. Bir Excel dosyasını belediyenin sitesine yüklemek başlangıç sayılabilir, ancak gerçek anlamda kullanılabilir veri için makine tarafından okunabilir formatlar gerekir.</p>

<p>Bir veri kümesinin faydasını basitçe şöyle düşünebiliriz:</p>

\[F = E \times G \times A\]

<p>Burada $E$ erişilebilirliği, $G$ güncelliği, $A$ ise anlaşılabilirliği temsil eder. Çarpanlardan biri sıfıra yaklaşırsa toplam fayda da düşer. Örneğin güncel olmayan otobüs konumları, teknik olarak erişilebilir olsa bile yolcuyu yanlış durağa koşturabilir!</p>

<table>
  <thead>
    <tr>
      <th>Paylaşım yöntemi</th>
      <th style="text-align: right">Güncellik</th>
      <th style="text-align: right">Yazılımla kullanım</th>
      <th>Uygun senaryo</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>PDF raporu</td>
      <td style="text-align: right">Düşük</td>
      <td style="text-align: right">Zor</td>
      <td>Yıllık faaliyet raporları</td>
    </tr>
    <tr>
      <td>CSV dosyası</td>
      <td style="text-align: right">Orta</td>
      <td style="text-align: right">Kolay</td>
      <td>Bütçe ve istatistik verileri</td>
    </tr>
    <tr>
      <td>REST API</td>
      <td style="text-align: right">Yüksek</td>
      <td style="text-align: right">Çok kolay</td>
      <td>Ulaşım ve sensör verileri</td>
    </tr>
    <tr>
      <td>GeoJSON</td>
      <td style="text-align: right">Yüksek</td>
      <td style="text-align: right">Çok kolay</td>
      <td>Harita ve konum uygulamaları</td>
    </tr>
  </tbody>
</table>

<h2 id="belediye-apisi-nasıl-çalışır">Belediye API’si nasıl çalışır?</h2>

<p>API, belediyenin veri sistemleri ile dışarıdaki uygulamalar arasında kontrollü bir köprü kurar. İstemci belirli bir adrese HTTP isteği gönderir; sunucu çoğunlukla JSON biçiminde yanıt verir. Örneğin <code class="language-plaintext highlighter-rouge">/api/v1/otobusler</code> adresi araç listesini, <code class="language-plaintext highlighter-rouge">/api/v1/otobusler/34</code> adresi ise belirli bir aracı döndürebilir.</p>

<p>Arka planda tipik akış şu şekildedir:</p>

<ol>
  <li>Sensörler veya belediye birimleri ham veriyi üretir.</li>
  <li>ETL süreci veriyi temizler, standartlaştırır ve doğrular.</li>
  <li>Kişisel ya da hassas alanlar anonimleştirilir.</li>
  <li>API katmanı yalnızca paylaşılması uygun alanları sunar.</li>
  <li>Portal; açıklama, lisans, güncelleme tarihi ve örnek sorgular yayımlar.</li>
</ol>

<p>Bir geliştirici, durak verisini Python ile şöyle kullanabilir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">requests</span>

<span class="n">url</span> <span class="o">=</span> <span class="sh">'</span><span class="s">https://veri.ornek.bel.tr/api/v1/duraklar</span><span class="sh">'</span>
<span class="n">params</span> <span class="o">=</span> <span class="p">{</span><span class="sh">'</span><span class="s">ilce</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">merkez</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">limit</span><span class="sh">'</span><span class="p">:</span> <span class="mi">10</span><span class="p">}</span>

<span class="n">response</span> <span class="o">=</span> <span class="n">requests</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">url</span><span class="p">,</span> <span class="n">params</span><span class="o">=</span><span class="n">params</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
<span class="n">response</span><span class="p">.</span><span class="nf">raise_for_status</span><span class="p">()</span>

<span class="k">for</span> <span class="n">durak</span> <span class="ow">in</span> <span class="n">response</span><span class="p">.</span><span class="nf">json</span><span class="p">()[</span><span class="sh">'</span><span class="s">results</span><span class="sh">'</span><span class="p">]:</span>
    <span class="nf">print</span><span class="p">(</span><span class="n">durak</span><span class="p">[</span><span class="sh">'</span><span class="s">ad</span><span class="sh">'</span><span class="p">],</span> <span class="n">durak</span><span class="p">[</span><span class="sh">'</span><span class="s">konum</span><span class="sh">'</span><span class="p">])</span>
</code></pre></div></div>

<p>Bu kod API’ye filtreli bir GET isteği gönderir, bağlantı hatalarını denetler ve dönen ilk on durağın adını ve konumunu yazdırır. Gerçek projelerde sayfalama, önbellekleme ve istek sınırı bilgileri de dikkate alınmalıdır.</p>

<h2 id="şeffaflık-kadar-mahremiyet-de-önemli">Şeffaflık kadar mahremiyet de önemli</h2>

<p>Her belediye verisi açılmamalıdır. Kişilerin adresleri, sağlık bilgileri, araç plakaları veya hareket geçmişleri doğrudan paylaşılırsa açık veri faydadan çok zarar üretebilir. Bu nedenle isim kaldırma tek başına yeterli değildir; farklı veri kümeleri birleştirildiğinde kişinin yeniden tanınması mümkün olabilir.</p>

<table>
  <thead>
    <tr>
      <th>Açılabilecek veri</th>
      <th>Korunması gereken veri</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Mahalle bazlı nüfus istatistiği</td>
      <td>Kişi ve açık adres listesi</td>
    </tr>
    <tr>
      <td>Anlık toplu taşıma konumu</td>
      <td>Bireysel seyahat geçmişi</td>
    </tr>
    <tr>
      <td>Toplam belediye harcaması</td>
      <td>Personelin banka bilgileri</td>
    </tr>
    <tr>
      <td>Ölçüm istasyonu hava kalitesi</td>
      <td>Vatandaşa ait sağlık kaydı</td>
    </tr>
  </tbody>
</table>

<p>API anahtarları, hız sınırlama, anonimleştirme ve erişim kayıtları güvenliğin temel araçlarıdır. Ayrıca veri lisansı açıkça belirtilmelidir; “internette bulunuyor” ifadesi, verinin sınırsızca kullanılabileceği anlamına gelmez.</p>

<h2 id="vatandaş-için-gerçek-değer">Vatandaş için gerçek değer</h2>

<p>İyi tasarlanmış bir portal yalnızca dosya deposu değildir. Veri sözlüğü, sürüm bilgisi, API dokümantasyonu, hata bildirim kanalı ve örnek projeler sunar. Bunun sonucunda erişilebilir rota uygulamaları, mahalle bütçesi panoları, hava kalitesi uyarıları veya boş otopark haritaları geliştirilebilir.</p>

<p>Kısacası şehir verisi paylaşıldığında belediye tek üretici olmaktan çıkar; vatandaşlar da çözüm ortağına dönüşür. Doğru standartlar, güncel API’ler ve güçlü mahremiyet kuralları sayesinde açık veri, dijital şehrin vitrini değil çalışan motoru olabilir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="açık veri" /><category term="api" /><category term="belediye" /><category term="akıllı şehir" /><category term="veri güvenliği" /><category term="şehircilik" /><summary type="html"><![CDATA[Bir şehir her gün devasa miktarda veri üretir: otobüslerin konumu, hava kalitesi, yol çalışmaları, bütçe harcamaları, park doluluk oranları ve hatta hangi mahallede kaç ağaç bulunduğu… Belediyeler bu verileri yalnızca kurum içinde saklamak yerine açık veri portalları ve API’ler aracılığıyla paylaşabilir. Böylece vatandaşlar, araştırmacılar ve yazılımcılar şehrin dijital hazinesinden yararlanarak yeni uygulamalar geliştirebilir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/acik-veri-portallari-40.png" /><media:content medium="image" url="https://program.sonsuz.us/img/acik-veri-portallari-40.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Akıllı Aydınlatmada Scene Programlama: Tek Komutla Işık Orkestrası</title><link href="https://program.sonsuz.us/posts/akilli-aydinlatmada-scene-programlama-tek-komutla-isik-orkestrasi/" rel="alternate" type="text/html" title="Akıllı Aydınlatmada Scene Programlama: Tek Komutla Işık Orkestrası" /><published>2026-10-30T00:00:00+00:00</published><updated>2026-10-30T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/akilli-aydinlatmada-scene-programlama-tek-komutla-isik-orkestrasi</id><content type="html" xml:base="https://program.sonsuz.us/posts/akilli-aydinlatmada-scene-programlama-tek-komutla-isik-orkestrasi/"><![CDATA[<p><img src="/img/akilli-aydinlatmada-scene-22.svg" alt="akilli-aydinlatmada-scene-22" /></p>

<p>Bir odadaki beş farklı lambayı film izlemeye uygun hâle getirmek için her birini ayrı ayrı ayarladığınızı düşünün: tavan ışığını kıs, lambaderi mora çevir, LED şeridi yak… Akıllı aydınlatma sistemlerindeki <strong>scene</strong>, yani sahne yaklaşımı, bu küçük kumanda maratonunu tek komuta indirir. “Sinema” sahnesini çağırdığınızda bütün ışıklar önceden belirlenen renk, parlaklık ve geçiş sürelerine senkronize biçimde ulaşır.</p>

<p>``</p>

<h2 id="scene-tam-olarak-nedir">Scene tam olarak nedir?</h2>

<p>Scene, bir veya daha fazla cihazın hedef durumlarını saklayan mantıksal bir anlık görüntüdür. Bir sahne çalıştırıldığında sistem ilgili cihazlara <code class="language-plaintext highlighter-rouge">açık/kapalı</code>, parlaklık, renk sıcaklığı veya RGB değeri gibi komutlar gönderir.</p>

<p>Bir ışığın basitleştirilmiş durumu şöyle gösterilebilir:</p>

\[L_i = (p_i, b_i, r_i, g_i, b_i', t_i)\]

<p>Burada $p_i$ güç durumunu, $b_i$ parlaklığı, $(r_i,g_i,b_i’)$ renk bileşenlerini, $t_i$ ise geçiş süresini temsil eder. Bir sahne de $n$ adet ışığın durum kümesidir:</p>

\[S = \{L_1, L_2, \ldots, L_n\}\]

<p>Yani scene komutu sihir değil; önceden tanımlanmış durumların topluca uygulanmasıdır. Yine de salon bir anda bilim kurgu filmine dönüşünce biraz sihirli görünebilir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th style="text-align: right">Komut sayısı</th>
      <th>Tutarlılık</th>
      <th>Kullanım örneği</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Tekil kontrol</td>
      <td style="text-align: right">Her ışık için ayrı</td>
      <td>Kullanıcıya bağlı</td>
      <td>Okuma lambasını açmak</td>
    </tr>
    <tr>
      <td>Scene</td>
      <td style="text-align: right">Genellikle tek</td>
      <td>Yüksek</td>
      <td>Sinema veya yemek modu</td>
    </tr>
    <tr>
      <td>Otomasyon</td>
      <td style="text-align: right">Koşula bağlı</td>
      <td>Kurallara bağlı</td>
      <td>Gün batınca sahneyi çağırmak</td>
    </tr>
  </tbody>
</table>

<h2 id="senkronizasyon-nasıl-sağlanır">Senkronizasyon nasıl sağlanır?</h2>

<p>Merkezî sistem önce sahne tanımını okur, ardından komutları ağ üzerinden ampullere veya köprüye iletir. Zigbee gibi ağlarda grup adresleme kullanılıyorsa tek yayın mesajı aynı gruptaki cihazlara ulaşabilir. Wi-Fi tabanlı sistemlerde ise komutlar çoğunlukla ayrı ayrı gönderilir.</p>

<p>Gerçek dünyada “aynı anda” ifadesi yaklaşık bir hedeftir. Cihaz $i$ için toplam gecikme şöyle modellenebilir:</p>

\[T_i = T_{işleme} + T_{ağ} + T_{cihaz}\]

<p>Işıklar arasındaki fark $\Delta T = \max(T_i)-\min(T_i)$ küçüldükçe geçiş daha senkron görünür. Grup mesajları, yerel ağ kullanımı ve ortak geçiş süresi bu farkı azaltır. Bulut üzerinden çalışan çözümlerde internet gecikmesi, orkestraya geç kalan bir trompetçi ekleyebilir.</p>

<h2 id="home-assistant-ile-örnek-sahne">Home Assistant ile örnek sahne</h2>

<p>Aşağıdaki YAML tanımı, üç ışığın hedef özelliklerini saklar. <code class="language-plaintext highlighter-rouge">transition</code> alanı değişimin iki saniyede yumuşak biçimde yapılmasını sağlar.</p>

<div class="language-yaml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="na">scene</span><span class="pi">:</span>
  <span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Sinema Modu</span>
    <span class="na">entities</span><span class="pi">:</span>
      <span class="na">light.tavan</span><span class="pi">:</span>
        <span class="na">state</span><span class="pi">:</span> <span class="s2">"</span><span class="s">off"</span>
      <span class="na">light.lambader</span><span class="pi">:</span>
        <span class="na">state</span><span class="pi">:</span> <span class="s2">"</span><span class="s">on"</span>
        <span class="na">brightness</span><span class="pi">:</span> <span class="m">65</span>
        <span class="na">rgb_color</span><span class="pi">:</span> <span class="pi">[</span><span class="nv">90</span><span class="pi">,</span> <span class="nv">30</span><span class="pi">,</span> <span class="nv">140</span><span class="pi">]</span>
        <span class="na">transition</span><span class="pi">:</span> <span class="m">2</span>
      <span class="na">light.tv_seridi</span><span class="pi">:</span>
        <span class="na">state</span><span class="pi">:</span> <span class="s2">"</span><span class="s">on"</span>
        <span class="na">brightness</span><span class="pi">:</span> <span class="m">110</span>
        <span class="na">color_temp_kelvin</span><span class="pi">:</span> <span class="m">3000</span>
        <span class="na">transition</span><span class="pi">:</span> <span class="m">2</span>
</code></pre></div></div>

<p>Sahneyi bir otomasyondan, panelden veya sesli asistandan çağırabiliriz:</p>

<div class="language-yaml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="na">service</span><span class="pi">:</span> <span class="s">scene.turn_on</span>
<span class="na">target</span><span class="pi">:</span>
  <span class="na">entity_id</span><span class="pi">:</span> <span class="s">scene.sinema_modu</span>
<span class="na">data</span><span class="pi">:</span>
  <span class="na">transition</span><span class="pi">:</span> <span class="m">2</span>
</code></pre></div></div>

<p>İlk blok <strong>hangi durumun oluşturulacağını</strong>, ikinci blok ise <strong>bu durumun ne zaman uygulanacağını</strong> ifade eder. Bu ayrım önemlidir: Scene durum tarif eder; otomasyon ise tetikleyici ve koşullarla karar verir.</p>

<h2 id="mqtt-ile-kendi-denetleyicini-yazmak">MQTT ile kendi denetleyicini yazmak</h2>

<p>Özel bir IoT projesinde sahne, JSON olarak MQTT konusuna yayınlanabilir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">json</span>
<span class="kn">import</span> <span class="n">paho.mqtt.publish</span> <span class="k">as</span> <span class="n">publish</span>

<span class="n">scene</span> <span class="o">=</span> <span class="p">{</span>
    <span class="sh">"</span><span class="s">group</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">salon</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">brightness</span><span class="sh">"</span><span class="p">:</span> <span class="mi">35</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">color</span><span class="sh">"</span><span class="p">:</span> <span class="p">{</span><span class="sh">"</span><span class="s">r</span><span class="sh">"</span><span class="p">:</span> <span class="mi">80</span><span class="p">,</span> <span class="sh">"</span><span class="s">g</span><span class="sh">"</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span> <span class="sh">"</span><span class="s">b</span><span class="sh">"</span><span class="p">:</span> <span class="mi">130</span><span class="p">},</span>
    <span class="sh">"</span><span class="s">transition_ms</span><span class="sh">"</span><span class="p">:</span> <span class="mi">2000</span>
<span class="p">}</span>

<span class="n">publish</span><span class="p">.</span><span class="nf">single</span><span class="p">(</span>
    <span class="sh">"</span><span class="s">home/lights/scene</span><span class="sh">"</span><span class="p">,</span>
    <span class="n">payload</span><span class="o">=</span><span class="n">json</span><span class="p">.</span><span class="nf">dumps</span><span class="p">(</span><span class="n">scene</span><span class="p">),</span>
    <span class="n">hostname</span><span class="o">=</span><span class="sh">"</span><span class="s">192.168.1.20</span><span class="sh">"</span>
<span class="p">)</span>
</code></pre></div></div>

<p>Bu kod sahne verisini tek mesaj hâlinde yayımlar. Abone olan denetleyici mesajı ayrıştırıp ilgili ışıklara uygular. Üretim ortamında kimlik doğrulama, TLS, hata kontrolü ve çevrimdışı cihaz yönetimi de eklenmelidir.</p>

<h2 id="sağlam-sahneler-için-ipuçları">Sağlam sahneler için ipuçları</h2>

<ul>
  <li>Cihazları işlevlerine göre gruplandırın.</li>
  <li>Bulut yerine mümkünse yerel kontrol kullanın.</li>
  <li>Tüm ışıklara ortak geçiş süresi verin.</li>
  <li>Erişilemeyen cihazlarda işlemi tamamen durdurmak yerine kalanları çalıştırın.</li>
  <li>Sahnenin mevcut ayarları mı kaydedeceğine, sabit değerler mi kullanacağına karar verin.</li>
</ul>

<p>İyi tasarlanmış bir scene sistemi, karmaşık cihaz ayrıntılarını kullanıcıdan saklar. Kullanıcı yalnızca “Çalışma”, “Parti” veya “Uyku” der; arka plandaki yazılım ise ışık orkestrasının şefliğini üstlenir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Program" /><category term="akıllı aydınlatma" /><category term="scene programlama" /><category term="iot" /><category term="otomasyon" /><category term="mqtt" /><category term="home assistant" /><summary type="html"><![CDATA[Bir odadaki beş farklı lambayı film izlemeye uygun hâle getirmek için her birini ayrı ayrı ayarladığınızı düşünün: tavan ışığını kıs, lambaderi mora çevir, LED şeridi yak… Akıllı aydınlatma sistemlerindeki scene, yani sahne yaklaşımı, bu küçük kumanda maratonunu tek komuta indirir. “Sinema” sahnesini çağırdığınızda bütün ışıklar önceden belirlenen renk, parlaklık ve geçiş sürelerine senkronize biçimde ulaşır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/akilli-aydinlatmada-scene-22.png" /><media:content medium="image" url="https://program.sonsuz.us/img/akilli-aydinlatmada-scene-22.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Akıllı Evin Ortak Dili: Zigbee, Z-Wave ve Matter Karşılaştırması</title><link href="https://program.sonsuz.us/posts/akilli-evin-ortak-dili-zigbee-z-wave-ve-matter-karsilastirmasi/" rel="alternate" type="text/html" title="Akıllı Evin Ortak Dili: Zigbee, Z-Wave ve Matter Karşılaştırması" /><published>2026-10-30T00:00:00+00:00</published><updated>2026-10-30T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/akilli-evin-ortak-dili-zigbee-z-wave-ve-matter-karsilastirmasi</id><content type="html" xml:base="https://program.sonsuz.us/posts/akilli-evin-ortak-dili-zigbee-z-wave-ve-matter-karsilastirmasi/"><![CDATA[<p>Bir hareket sensörü lambaya “Biri geldi!” derken, termostat kombiden yardım ister. Peki farklı markaların cihazları aynı evde birbirini nasıl anlar? Akıllı ev protokolleri, bu dijital apartmanın haberleşme kurallarını belirler. Zigbee, Z-Wave ve Matter ise benzer ihtiyaçları farklı katmanlarda çözer. Doğru seçim, yalnızca kutudaki logoya bakmaktan biraz daha fazlasını gerektirir.</p>

<p>``</p>

<h2 id="önce-katmanları-ayıralım">Önce katmanları ayıralım</h2>

<p>Haberleşmenin iki temel sorusu vardır: “Veriyi nasıl taşıyoruz?” ve “Taşınan veri ne anlama geliyor?” Radyo teknolojisi ilk soruya, uygulama protokolü ikinci soruya yanıt verir. Ortak frekans kullanmak, ortak dili konuşmak anlamına gelmez; cihazların komutları, güvenlik kurallarını ve katılım süreçlerini de anlaması gerekir.</p>

<p>Zigbee ve Z-Wave kendi ağ ve uygulama yapılarını sunar. Matter ise IP üzerinde çalışan bir uygulama standardıdır; veriyi Thread, Wi-Fi veya Ethernet taşıyabilir. Bluetooth LE genellikle ilk kurulumda yardımcı olur, normal Matter haberleşmesinin taşıyıcısı değildir.</p>

<p>Örgü, yani <em>mesh</em> ağlarda mesajlar ara cihazlardan geçebilir. Her atlamanın bağımsız başarı olasılığı $p$ ise, $h$ atlamalı basitleştirilmiş bir yol için $P = p^h$ olur. Örneğin $0.99^3 = 0.970299$. Bu, yeniden denemeleri dışlayan öğretici bir modeldir; gerçek performansı yerleşim, parazit ve alternatif yollar belirler.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>Zigbee</th>
      <th>Z-Wave</th>
      <th>Matter</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Temel yaklaşım</td>
      <td>IP dışı cihaz ağı</td>
      <td>IP dışı cihaz ağı</td>
      <td>IP tabanlı uygulama standardı</td>
    </tr>
    <tr>
      <td>Taşıma</td>
      <td>Genellikle 2,4 GHz</td>
      <td>Bölgesel sub-GHz bantları</td>
      <td>Thread, Wi-Fi, Ethernet</td>
    </tr>
    <tr>
      <td>Ağ düzeni</td>
      <td>Mesh</td>
      <td>Klasik ağlarda mesh</td>
      <td>Taşıyıcıya bağlı</td>
    </tr>
    <tr>
      <td>Temel altyapı</td>
      <td>Koordinatör</td>
      <td>Denetleyici</td>
      <td>Matter denetleyicisi</td>
    </tr>
    <tr>
      <td>Güçlü taraf</td>
      <td>Geniş ürün seçeneği</td>
      <td>Bölgesel, düşük frekanslı haberleşme</td>
      <td>Ekosistemler arası ortak dil</td>
    </tr>
  </tbody>
</table>

<h2 id="zigbee-kalabalık-ve-ekonomik-mahalle">Zigbee: Kalabalık ve ekonomik mahalle</h2>

<p>Zigbee, sensörlerden ampullere uzanan geniş ürün çeşitliliğiyle dikkat çeker. Koordinatör ağı oluşturur; yönlendirici cihazlar mesajları aktarır. Pilli uç cihazlar çoğunlukla uyuyarak enerji tasarrufu yapar ve başkalarının mesajlarını taşımaz. Şebekeden beslenen her cihazın yönlendirici olduğunu varsaymamak gerekir.</p>

<p>Dezavantajı, yaygın kullanılan 2,4 GHz bandını Wi-Fi ile paylaşmasıdır. Kanal planlaması önemlidir. Ayrıca “Zigbee destekli” etiketi, her cihazın her merkezde bütün özellikleriyle çalışacağını garanti etmez. Satın almadan önce merkezin uyumluluk listesini kontrol edin.</p>

<h2 id="z-wave-daha-sakin-frekansların-komşusu">Z-Wave: Daha sakin frekansların komşusu</h2>

<p>Z-Wave, bölgeye göre değişen sub-GHz frekanslarını kullanır. Avrupa ürünlerinde sıklıkla 868 MHz çevresi görülür; ABD ürünleri farklı bantlardadır. Bu yüzden yurt dışından alınan cihazın yerel denetleyiciyle ve mevzuatla uyumunu kontrol etmek şarttır.</p>

<p>Düşük frekans, benzer koşullarda yayılım açısından avantaj sağlayabilir; ancak beton duvarları sihirli biçimde ortadan kaldırmaz. Sertifikasyon birlikte çalışabilirliği destekler, yine de denetleyicinin özellik desteği önemlidir. Ayrıca Z-Wave Long Range, klasik mesh yaklaşımından farklı olarak yıldız topolojisi kullanır.</p>

<h2 id="matter-ortak-sözlük-farklı-yollar">Matter: Ortak sözlük, farklı yollar</h2>

<p>Matter’ın büyük vaadi, markalar arasındaki uygulama dilini standartlaştırmaktır. Desteklenen cihazlar Multi-Admin özelliğiyle birden fazla ekosisteme eklenebilir. Ancak uygulamaların sunduğu özellikler, cihaz türü desteği ve Matter sürümleri hâlâ kontrol edilmelidir.</p>

<p>Thread kullanan Matter cihazları, evin diğer IP ağlarına ulaşmak için bir Thread sınır yönlendiricisinden yararlanır. Matter denetleyicisi ise cihazın kurulumu ve yönetimiyle ilgilenir. Bu roller aynı üründe bulunabilir ama aynı şey değildir.</p>

<p>Eski Zigbee veya Z-Wave cihazları kendiliğinden Matter cihazına dönüşmez. Uyumlu bir köprü, yalnızca desteklediği cihaz türlerini ve özelliklerini Matter tarafına sunabilir.</p>

<h2 id="yazılım-tarafında-ortak-komut-modeli">Yazılım tarafında ortak komut modeli</h2>

<p>Bir otomasyon uygulaması, cihazın protokolünü her iş kuralına taşımak yerine adaptör seçimini merkezileştirebilir. Aşağıdaki Python örneği gerçek radyo iletişimi yapmaz; komutun hangi entegrasyona yönlendirileceğini planlar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="n">dataclasses</span> <span class="kn">import</span> <span class="n">dataclass</span>

<span class="nd">@dataclass</span><span class="p">(</span><span class="n">frozen</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="k">class</span> <span class="nc">Device</span><span class="p">:</span>
    <span class="n">name</span><span class="p">:</span> <span class="nb">str</span>
    <span class="n">protocol</span><span class="p">:</span> <span class="nb">str</span>
    <span class="n">online</span><span class="p">:</span> <span class="nb">bool</span>

<span class="n">ADAPTERS</span> <span class="o">=</span> <span class="p">{</span>
    <span class="sh">'</span><span class="s">zigbee</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">zigbee_gateway</span><span class="sh">'</span><span class="p">,</span>
    <span class="sh">'</span><span class="s">z-wave</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">zwave_controller</span><span class="sh">'</span><span class="p">,</span>
    <span class="sh">'</span><span class="s">matter</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">matter_controller</span><span class="sh">'</span><span class="p">,</span>
<span class="p">}</span>

<span class="k">def</span> <span class="nf">plan_command</span><span class="p">(</span><span class="n">device</span><span class="p">:</span> <span class="n">Device</span><span class="p">,</span> <span class="n">enabled</span><span class="p">:</span> <span class="nb">bool</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">dict</span><span class="p">:</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">device</span><span class="p">.</span><span class="n">online</span><span class="p">:</span>
        <span class="k">raise</span> <span class="nc">ConnectionError</span><span class="p">(</span><span class="sh">'</span><span class="s">Cihaz çevrimdışı</span><span class="sh">'</span><span class="p">)</span>
    <span class="k">if</span> <span class="n">device</span><span class="p">.</span><span class="n">protocol</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">ADAPTERS</span><span class="p">:</span>
        <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">'</span><span class="s">Desteklenmeyen protokol</span><span class="sh">'</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">{</span>
        <span class="sh">'</span><span class="s">adapter</span><span class="sh">'</span><span class="p">:</span> <span class="n">ADAPTERS</span><span class="p">[</span><span class="n">device</span><span class="p">.</span><span class="n">protocol</span><span class="p">],</span>
        <span class="sh">'</span><span class="s">device</span><span class="sh">'</span><span class="p">:</span> <span class="n">device</span><span class="p">.</span><span class="n">name</span><span class="p">,</span>
        <span class="sh">'</span><span class="s">action</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">set_power</span><span class="sh">'</span><span class="p">,</span>
        <span class="sh">'</span><span class="s">value</span><span class="sh">'</span><span class="p">:</span> <span class="n">enabled</span><span class="p">,</span>
    <span class="p">}</span>

<span class="n">lamp</span> <span class="o">=</span> <span class="nc">Device</span><span class="p">(</span><span class="sh">'</span><span class="s">salon_lambası</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">matter</span><span class="sh">'</span><span class="p">,</span> <span class="bp">True</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="nf">plan_command</span><span class="p">(</span><span class="n">lamp</span><span class="p">,</span> <span class="bp">True</span><span class="p">))</span>
</code></pre></div></div>

<p>Gerçek adaptör, ortak <code class="language-plaintext highlighter-rouge">set_power</code> isteğini cihazın desteklediği komuta çevirir. Kimlik doğrulama, zaman aşımı, yeniden deneme ve durum doğrulaması ayrıca uygulanmalıdır. Böylece otomasyon mantığı, haberleşme ayrıntılarından bağımsız kalır.</p>

<h2 id="hangisini-seçmeli">Hangisini seçmeli?</h2>

<p>Uygun fiyatlı sensör çeşitliliğinde Zigbee, bölgesel frekans avantajında Z-Wave, ekosistemler arası kullanımda Matter güçlü adaylardır. Yeni kurulumda yalnızca protokolü değil, gereken denetleyiciyi, çevrimdışı çalışma davranışını ve güncelleme politikasını da değerlendirin. Güvenli eşleştirme kullanın, yazılımı güncel tutun ve otomasyonlarınızı internet kesildiğinde sınayın. En akıllı ev, internet gidince ev olmayı unutmayan evdir.</p>

<p><img src="/img/akilli-evin-ortak-54.svg" alt="akilli-evin-ortak-54" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="akıllı ev" /><category term="zigbee" /><category term="z-wave" /><category term="matter" /><category term="thread" /><category term="iot" /><summary type="html"><![CDATA[Bir hareket sensörü lambaya “Biri geldi!” derken, termostat kombiden yardım ister. Peki farklı markaların cihazları aynı evde birbirini nasıl anlar? Akıllı ev protokolleri, bu dijital apartmanın haberleşme kurallarını belirler. Zigbee, Z-Wave ve Matter ise benzer ihtiyaçları farklı katmanlarda çözer. Doğru seçim, yalnızca kutudaki logoya bakmaktan biraz daha fazlasını gerektirir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/akilli-evin-ortak-54.png" /><media:content medium="image" url="https://program.sonsuz.us/img/akilli-evin-ortak-54.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Beyin Sinyalinden Komuta: EEG ve Makine Öğrenmesiyle Niyet Sınıflandırma</title><link href="https://program.sonsuz.us/posts/beyin-sinyalinden-komuta-eeg-ve-makine-ogrenmesiyle-niyet-siniflandirma/" rel="alternate" type="text/html" title="Beyin Sinyalinden Komuta: EEG ve Makine Öğrenmesiyle Niyet Sınıflandırma" /><published>2026-10-30T00:00:00+00:00</published><updated>2026-10-30T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/beyin-sinyalinden-komuta-eeg-ve-makine-ogrenmesiyle-niyet-siniflandirma</id><content type="html" xml:base="https://program.sonsuz.us/posts/beyin-sinyalinden-komuta-eeg-ve-makine-ogrenmesiyle-niyet-siniflandirma/"><![CDATA[<p>Bir robot kolunu yalnızca hareket etmeyi hayal ederek yönlendirmek, bilim kurgu kulübünden çıkıp araştırma laboratuvarlarına taşındı. Beyin-bilgisayar arayüzleri, EEG sinyallerindeki örüntüleri makine öğrenmesiyle komutlara dönüştürüyor. Ancak burada küçük bir sürpriz var: Sistem, zihninizdeki cümleleri okumuyor; belirli görevlerle ilişkili istatistiksel izleri tanımayı öğreniyor.</p>

<p>``</p>

<h2 id="eeg-gerçekten-neyi-ölçer">EEG gerçekten neyi ölçer?</h2>

<p>Elektroensefalografi, kafa derisine yerleştirilen elektrotlarla elektriksel potansiyel farklarını kaydeder. Ölçülen sinyal, çok sayıda nöronun toplu etkinliğinden doğar; tek bir nöronun konuşmasını dinlemek değildir. Kafatası, dokular ve elektrot konumları bu etkinliği karıştırır. Basitleştirilmiş modelimiz $x(t)=As(t)+n(t)$ olsun: $s(t)$ kaynakları, $A$ karışımı, $n(t)$ ise gürültüyü temsil eder.</p>

<p>Dolayısıyla EEG sınıflandırması, kalabalık bir kafede belirli bir konuşma tarzını ayırt etmeye benzer. Üstelik göz kırpmaları ve çene kasları da masaya davetsiz katılır!</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Aranan örüntü</th>
      <th>Tipik kullanım</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Motor imgeleme</td>
      <td>Mü ve beta ritimlerindeki değişim</td>
      <td>Sağ/sol hareket niyeti</td>
    </tr>
    <tr>
      <td>P300</td>
      <td>Hedef uyaran sonrası olay ilişkili yanıt</td>
      <td>Harf veya seçenek seçimi</td>
    </tr>
    <tr>
      <td>SSVEP</td>
      <td>Yanıp sönen hedefin frekansıyla ilişkili yanıt</td>
      <td>Ekrandaki hedefi seçme</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/beyin-sinyalinden-komuta-26.svg" alt="beyin-sinyalinden-komuta-26" /></p>

<p>Bu yaklaşımların eğitim düzenekleri farklıdır; tek bir modelin hepsini kendiliğinden anlayacağını varsayamayız.</p>

<h2 id="ham-sinyalden-öğrenilebilir-örneğe">Ham sinyalden öğrenilebilir örneğe</h2>

<p>Motor imgelemede kullanıcı, örneğin sağ veya sol elini hareket ettirmeyi hayal eder. Sensörimotor bölgelerdeki yaklaşık 8–13 Hz mü ve 13–30 Hz beta ritimleri bu görev sırasında değişebilir. <strong>Etiket</strong>, tahmin edilen düşünce değil, deneyde kullanıcıya verilen görevdir.</p>

<p>İşlem hattını dört aşamada kurabiliriz:</p>

<ol>
  <li><strong>Kayıt ve etiketleme:</strong> Elektrot konumları, örnekleme hızı ve görev başlangıçları kaydedilir. Hatalı zamanlama, modele yanlış hikâyeyi anlatır.</li>
  <li><strong>Ön işleme:</strong> Motor imgeleme için örneğin 8–30 Hz bant geçiren filtre uygulanır. Göz ve kas artefaktları incelenir; öğrenilen temizleme dönüşümleri yalnızca eğitim verisine uydurulur.</li>
  <li><strong>Epoklama:</strong> Sürekli kayıt, görev başlangıcına göre zaman pencerelerine ayrılır. Pencerelerin gerçekten hedeflenen imgeleme dönemini kapsaması önemlidir.</li>
  <li><strong>Öznitelik ve sınıflandırma:</strong> Bant gücü veya uzamsal filtrelerle çıkarılan özellikler, görev etiketleriyle eşleştirilir.</li>
</ol>

<p>Filtrelenmiş bir banttaki yaklaşık güç şöyle hesaplanabilir:</p>

\[P_b=\frac{1}{N}\sum_{i=1}^{N}x_b[i]^2\]

<p>Burada $N$ örnek sayısıdır. Güç, ritmin ne kadar baskın olduğunu özetler; fakat tek başına niyetin kesin kanıtı değildir.</p>

<h2 id="csp-ve-lda-i̇yi-bir-başlangıç-ikilisi">CSP ve LDA: İyi bir başlangıç ikilisi</h2>

<p><strong>Common Spatial Patterns</strong>, iki sınıfın varyanslarını birbirinden ayıran uzamsal filtreler öğrenir. Örneğin bir bileşenin varyansı sağ el imgelemesinde yüksek, sol el imgelemesinde düşük olabilir. Log-varyans özellikleri daha sonra <strong>Linear Discriminant Analysis</strong> sınıflandırıcısına verilir. LDA, sınıfların kovaryans yapısına ilişkin varsayımlarla doğrusal bir karar sınırı kurar. Derin öğrenmeden daha mütevazı görünür, ama küçük EEG veri kümelerinde güçlü bir başlangıçtır.</p>

<p>Aşağıdaki örnek, önceden filtrelenmiş MNE epoklarını kullanır. <code class="language-plaintext highlighter-rouge">labels</code> görev etiketlerini, <code class="language-plaintext highlighter-rouge">session_ids</code> oturum kimliklerini içerir. En az üç oturum ve uygun sınıf dağılımı gerekir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="n">mne.decoding</span> <span class="kn">import</span> <span class="n">CSP</span>
<span class="kn">from</span> <span class="n">sklearn.pipeline</span> <span class="kn">import</span> <span class="n">Pipeline</span>
<span class="kn">from</span> <span class="n">sklearn.discriminant_analysis</span> <span class="kn">import</span> <span class="n">LinearDiscriminantAnalysis</span>
<span class="kn">from</span> <span class="n">sklearn.model_selection</span> <span class="kn">import</span> <span class="n">StratifiedGroupKFold</span><span class="p">,</span> <span class="n">cross_val_score</span>

<span class="n">X</span> <span class="o">=</span> <span class="n">epochs</span><span class="p">.</span><span class="nf">get_data</span><span class="p">(</span><span class="n">copy</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>  <span class="c1"># deneme × kanal × zaman
</span>
<span class="n">model</span> <span class="o">=</span> <span class="nc">Pipeline</span><span class="p">([</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">csp</span><span class="sh">"</span><span class="p">,</span> <span class="nc">CSP</span><span class="p">(</span><span class="n">n_components</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">reg</span><span class="o">=</span><span class="sh">"</span><span class="s">oas</span><span class="sh">"</span><span class="p">,</span> <span class="n">log</span><span class="o">=</span><span class="bp">True</span><span class="p">)),</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">lda</span><span class="sh">"</span><span class="p">,</span> <span class="nc">LinearDiscriminantAnalysis</span><span class="p">(</span><span class="n">solver</span><span class="o">=</span><span class="sh">"</span><span class="s">lsqr</span><span class="sh">"</span><span class="p">,</span> <span class="n">shrinkage</span><span class="o">=</span><span class="sh">"</span><span class="s">auto</span><span class="sh">"</span><span class="p">))</span>
<span class="p">])</span>

<span class="n">cv</span> <span class="o">=</span> <span class="nc">StratifiedGroupKFold</span><span class="p">(</span><span class="n">n_splits</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">random_state</span><span class="o">=</span><span class="mi">42</span><span class="p">)</span>
<span class="n">scores</span> <span class="o">=</span> <span class="nf">cross_val_score</span><span class="p">(</span>
    <span class="n">model</span><span class="p">,</span> <span class="n">X</span><span class="p">,</span> <span class="n">labels</span><span class="p">,</span> <span class="n">groups</span><span class="o">=</span><span class="n">session_ids</span><span class="p">,</span>
    <span class="n">cv</span><span class="o">=</span><span class="n">cv</span><span class="p">,</span> <span class="n">scoring</span><span class="o">=</span><span class="sh">"</span><span class="s">balanced_accuracy</span><span class="sh">"</span>
<span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Dengeli doğruluk: </span><span class="si">{</span><span class="n">scores</span><span class="p">.</span><span class="nf">mean</span><span class="p">()</span><span class="si">:</span><span class="p">.</span><span class="mi">3</span><span class="n">f</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
</code></pre></div></div>

<p>Pipeline, CSP’nin her katlamada yalnızca eğitim bölümünden öğrenilmesini sağlar. Kovaryans düzenlileştirmesi tahminleri daha kararlı hâle getirebilir. Oturumlara göre ayırma ise aynı kaydın benzer parçalarının eğitim ve teste dağılmasını önler. Yeni kullanıcıya genelleme ölçülecekse gruplama kullanıcı düzeyinde yapılmalıdır.</p>

<h2 id="başarı-yalnızca-doğruluk-değildir">Başarı yalnızca doğruluk değildir</h2>

<p>Dengeli doğruluk, sınıfların eşit sayıda olmadığı durumlarda yararlıdır. Karışıklık matrisi, hangi komutların birbirine karıştığını gösterir. Ancak gerçek arayüzlerde gecikme, yanlış aktivasyon sıklığı ve kullanıcı yorgunluğu da değerlendirilmelidir. Çevrimdışı yüksek skor, çevrimiçi kullanım garantisi vermez; canlı sistemde nedensel filtreleme ve zaman bütçesi ayrıca sınanmalıdır.</p>

<p>Son aşamada model çıktısı, güven eşiği ve ardışık kararların birleştirilmesiyle komuta dönüştürülebilir. Düşük güvende “komut verme” seçeneği güvenliği artırabilir. EEG verisi hassastır; açık rıza ve sınırlı erişim gerekir. Kısacası başarılı arayüz, sihirli bir zihin okuyucu değil, dikkatle kalibre edilmiş bir örüntü tanıma sistemidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="eeg" /><category term="beyin-bilgisayar arayüzü" /><category term="makine öğrenmesi" /><category term="sinyal işleme" /><category term="python" /><category term="sınıflandırma" /><summary type="html"><![CDATA[Bir robot kolunu yalnızca hareket etmeyi hayal ederek yönlendirmek, bilim kurgu kulübünden çıkıp araştırma laboratuvarlarına taşındı. Beyin-bilgisayar arayüzleri, EEG sinyallerindeki örüntüleri makine öğrenmesiyle komutlara dönüştürüyor. Ancak burada küçük bir sürpriz var: Sistem, zihninizdeki cümleleri okumuyor; belirli görevlerle ilişkili istatistiksel izleri tanımayı öğreniyor.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/beyin-sinyalinden-komuta-26.png" /><media:content medium="image" url="https://program.sonsuz.us/img/beyin-sinyalinden-komuta-26.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">C++ Yapıcılar ve Yıkıcılar: Nesnelerin Doğumundan Vedaya Bellek Yönetimi</title><link href="https://program.sonsuz.us/posts/c-yapicilar-ve-yikicilar-nesnelerin-dogumundan-vedaya-bellek-yonetimi/" rel="alternate" type="text/html" title="C++ Yapıcılar ve Yıkıcılar: Nesnelerin Doğumundan Vedaya Bellek Yönetimi" /><published>2026-10-30T00:00:00+00:00</published><updated>2026-10-30T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/c-yapicilar-ve-yikicilar-nesnelerin-dogumundan-vedaya-bellek-yonetimi</id><content type="html" xml:base="https://program.sonsuz.us/posts/c-yapicilar-ve-yikicilar-nesnelerin-dogumundan-vedaya-bellek-yonetimi/"><![CDATA[<p><img src="/img/c-yapicilar-ve-65.svg" alt="c-yapicilar-ve-65" /></p>

<p>C++ nesnelerini küçük bir atölyenin çalışanları gibi düşünün: İşe başlarken ekipmanlarını hazırlamaları, ayrılırken de masalarını toplamaları gerekir. Yapıcılar nesneyi kullanıma hazırlar; yıkıcılar ise nesnenin sorumluluğundaki kaynakların bırakılmasını sağlar. Bu ikiliyi anlamak, yalnızca bellek sızıntılarını önlemek değil, güvenilir sınıflar tasarlamak için de temel bir adımdır.</p>

<p>``</p>

<h2 id="önce-teori-bellek-ile-nesne-aynı-şey-değildir">Önce teori: Bellek ile nesne aynı şey değildir</h2>

<p>Bir nesne için depolama alanı ayrılması, o nesnenin doğru biçimde kurulmuş olması anlamına gelmez. Yapıcı, üyeleri başlatır ve sınıfın geçerli durum koşullarını oluşturur. Örneğin bir tamponun boyutu ile sahip olduğu depolama alanı birbiriyle uyumlu olmalıdır. Bu koşullara <strong>sınıf değişmezi</strong>, yani invariant denir.</p>

<p>Yıkıcı kaynakları temizler; nesnenin kendi depolama alanının bırakılması ise kullanılan depolama modeline bağlıdır. Dolayısıyla “yıkıcı belleği siler” ifadesi tek başına eksiktir.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>Yapıcı</th>
      <th>Yıkıcı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>İsim</td>
      <td>Sınıf adı</td>
      <td>Sınıf adının önünde <code class="language-plaintext highlighter-rouge">~</code></td>
    </tr>
    <tr>
      <td>Dönüş türü</td>
      <td>Yok</td>
      <td>Yok</td>
    </tr>
    <tr>
      <td>Parametre</td>
      <td>Alabilir</td>
      <td>Alamaz</td>
    </tr>
    <tr>
      <td>Aşırı yükleme</td>
      <td>Yapılabilir</td>
      <td>Yapılamaz</td>
    </tr>
    <tr>
      <td>Temel görev</td>
      <td>Geçerli başlangıç durumu</td>
      <td>Kaynak temizliği</td>
    </tr>
  </tbody>
</table>

<h2 id="yapıcılar-başlangıç-ayarları-önemlidir">Yapıcılar: Başlangıç ayarları önemlidir</h2>

<p>Parametresiz çağrılabilen yapıcıya <strong>varsayılan yapıcı</strong> denir. Parametreli yapıcılar farklı başlangıç seçenekleri sunar. Bir yapıcının başka bir yapıcıyı çağırması ise delegasyon olarak adlandırılır; böylece aynı kurulum mantığını tekrar yazmazsınız.</p>

<p>Üyeleri yapıcı gövdesinde atamak yerine <strong>üye başlatma listesinde</strong> başlatmak genellikle daha doğrudur. Özellikle referans üyeler ve <code class="language-plaintext highlighter-rouge">const</code> üyeler burada başlatılmalıdır. Ayrıca üyeler, listede yazdığınız sırayla değil, sınıf içinde bildirildikleri sırayla başlatılır. Bu ayrıntı, başka bir üyeye bağlı başlangıç değerlerinde kritik önem taşır.</p>

<h2 id="uygulama-kendi-tamponunu-yöneten-sınıf">Uygulama: Kendi tamponunu yöneten sınıf</h2>

<p>Aşağıdaki sınıf, tamsayı dizisini kurulum sırasında edinir ve yıkım sırasında bırakır. Ham işaretçi burada mekanizmayı görünür kılmak için kullanılıyor:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;cstddef&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
#include</span> <span class="cpf">&lt;memory&gt;</span><span class="cp">
</span>
<span class="k">class</span> <span class="nc">Tampon</span> <span class="p">{</span>
    <span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">boyut_</span><span class="p">;</span>
    <span class="kt">int</span><span class="o">*</span> <span class="n">veri_</span><span class="p">;</span>

<span class="nl">public:</span>
    <span class="n">Tampon</span><span class="p">()</span> <span class="o">:</span> <span class="n">Tampon</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span> <span class="p">{}</span>

    <span class="k">explicit</span> <span class="nf">Tampon</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">boyut</span><span class="p">)</span>
        <span class="o">:</span> <span class="n">boyut_</span><span class="p">(</span><span class="n">boyut</span><span class="p">),</span> <span class="n">veri_</span><span class="p">(</span><span class="k">new</span> <span class="kt">int</span><span class="p">[</span><span class="n">boyut</span><span class="p">]{})</span> <span class="p">{}</span>

    <span class="n">Tampon</span><span class="p">(</span><span class="k">const</span> <span class="n">Tampon</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
    <span class="n">Tampon</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">Tampon</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>

    <span class="o">~</span><span class="n">Tampon</span><span class="p">()</span> <span class="p">{</span>
        <span class="k">delete</span><span class="p">[]</span> <span class="n">veri_</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">boyut</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">boyut_</span><span class="p">;</span>
    <span class="p">}</span>
<span class="p">};</span>

<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="n">Tampon</span> <span class="n">yerel</span><span class="p">;</span>
    <span class="k">auto</span> <span class="n">dinamik</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o">&lt;</span><span class="n">Tampon</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">8</span><span class="p">);</span>
    <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">yerel</span><span class="p">.</span><span class="n">boyut</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="sc">'\n'</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">Tampon()</code> dört elemanlık kuruluma yönlendirir. <code class="language-plaintext highlighter-rouge">explicit</code>, bir sayının istemeden <code class="language-plaintext highlighter-rouge">Tampon</code> nesnesine dönüştürülmesini engeller. Dizinin sonundaki <code class="language-plaintext highlighter-rouge">{}</code>, tamsayıları sıfırla başlatır. <code class="language-plaintext highlighter-rouge">delete[]</code>, <code class="language-plaintext highlighter-rouge">new[]</code> ile edinilen diziyi doğru biçimde bırakır.</p>

<p>Kopyalama işlemleri özellikle kapatıldı: Varsayılan kopyalama iki nesnenin aynı adresi sahiplenmesine, ardından aynı belleğin iki kez bırakılmasına yol açabilirdi. Bu sınıf taşıma işlemleri de tanımlamadığından, sahipliğin nesneler arasında aktarılmasını desteklemez.</p>

<h2 id="yaşam-süresi-ve-raii">Yaşam süresi ve RAII</h2>

<p><code class="language-plaintext highlighter-rouge">yerel</code>, blok sona erdiğinde otomatik olarak yıkılır. <code class="language-plaintext highlighter-rouge">dinamik</code> ise bir <code class="language-plaintext highlighter-rouge">std::unique_ptr</code> tarafından sahiplenilir; akıllı işaretçi yıkılınca yönettiği <code class="language-plaintext highlighter-rouge">Tampon</code> da yıkılır ve depolama alanı bırakılır. Bu örnekte önce <code class="language-plaintext highlighter-rouge">dinamik</code>, ardından <code class="language-plaintext highlighter-rouge">yerel</code> temizlenir.</p>

<table>
  <thead>
    <tr>
      <th>Kullanım</th>
      <th>Temizlik sorumluluğu</th>
      <th>Risk</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Yerel nesne</td>
      <td>Otomatik kapsam yönetimi</td>
      <td>Genellikle düşük</td>
    </tr>
    <tr>
      <td>Ham <code class="language-plaintext highlighter-rouge">new</code></td>
      <td>Programcı, uygun <code class="language-plaintext highlighter-rouge">delete</code> ile</td>
      <td>Unutulan temizlik</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">std::unique_ptr</code></td>
      <td>Sahiplik nesnesi</td>
      <td>Genellikle düşük</td>
    </tr>
  </tbody>
</table>

<p>Bu yaklaşımın adı <strong>RAII</strong>: Kaynak edinimini nesne kurulmasına, kaynak bırakmayı nesne yıkımına bağlamak. Kaynak yalnızca bellek değildir; dosya, kilit veya bağlantı da olabilir.</p>

<p>Basit bir kaynak sayacıyla hedefi ifade edebiliriz:</p>

\[R_{son} = R_{ilk} + R_{edinilen} - R_{birakilan}\]

<p>Başlangıçta sahip olunan kaynak sayısı sıfırsa, nesnenin işi bittiğinde sonuç yine sıfır olmalıdır. Atölyeden çıkarken masada unutulan tornavida istemiyoruz!</p>

<h2 id="i̇stisnalar-ve-güvenli-tasarım">İstisnalar ve güvenli tasarım</h2>

<p>Yapıcı istisna fırlatırsa nesne tamamen kurulmuş sayılmaz; o nesnenin yıkıcısı çağrılmaz. Ancak başarıyla kurulmuş üyeler ve taban sınıflar temizlenir. Bu yüzden kaynakları akıllı işaretçi veya standart kapsayıcı üyelerde tutmak, yarım kalan kurulumlarda da güvenlik sağlar.</p>

<p>Yıkıcılardan istisna kaçırmaktan kaçının: Özellikle başka bir istisna nedeniyle yığın çözülürken bu durum <code class="language-plaintext highlighter-rouge">std::terminate</code> ile programı sonlandırabilir. Taban sınıf işaretçisi üzerinden türetilmiş nesneleri silecekseniz, taban yıkıcısını <code class="language-plaintext highlighter-rouge">virtual</code> yapın.</p>

<p>Gerçek projelerde bu tampon için çoğunlukla <code class="language-plaintext highlighter-rouge">std::vector&lt;int&gt;</code> tercih edilir. Böylece özel yıkıcı ve sahiplik kodu yazmadan <strong>Rule of Zero</strong> yaklaşımına ulaşılır. En iyi temizlik kodu, çoğu zaman güvenilir bir üyeye devrettiğiniz koddur.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="c++" /><category term="constructors" /><category term="destructors" /><category term="bellek yönetimi" /><category term="raii" /><category term="nesne yaşam döngüsü" /><summary type="html"><![CDATA[C++ nesnelerini küçük bir atölyenin çalışanları gibi düşünün: İşe başlarken ekipmanlarını hazırlamaları, ayrılırken de masalarını toplamaları gerekir. Yapıcılar nesneyi kullanıma hazırlar; yıkıcılar ise nesnenin sorumluluğundaki kaynakların bırakılmasını sağlar. Bu ikiliyi anlamak, yalnızca bellek sızıntılarını önlemek değil, güvenilir sınıflar tasarlamak için de temel bir adımdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/c-yapicilar-ve-65.png" /><media:content medium="image" url="https://program.sonsuz.us/img/c-yapicilar-ve-65.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>