<?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-11-10T14:06:10+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">Arşivlerin Fısıltısını Duymak: Metin Madenciliğiyle Tarihi Belgeleri Anlamak</title><link href="https://program.sonsuz.us/posts/arsivlerin-fisiltisini-duymak-metin-madenciligiyle-tarihi-belgeleri-anlamak/" rel="alternate" type="text/html" title="Arşivlerin Fısıltısını Duymak: Metin Madenciliğiyle Tarihi Belgeleri Anlamak" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/arsivlerin-fisiltisini-duymak-metin-madenciligiyle-tarihi-belgeleri-anlamak</id><content type="html" xml:base="https://program.sonsuz.us/posts/arsivlerin-fisiltisini-duymak-metin-madenciligiyle-tarihi-belgeleri-anlamak/"><![CDATA[<p><img src="/img/arsivlerin-fisiltisini-duymak-56.svg" alt="arsivlerin-fisiltisini-duymak-56" /></p>

<p>Tozlu bir arşivdeki binlerce mektubu düşünün: değişen ticaret yolları, tekrar eden şikâyetler, unutulmuş yer adları… Hepsini tek tek okumak yıllar sürebilir. Metin madenciliği, bu belgeleri tarihçinin yerine yorumlayan sihirli bir makine değildir; nerelere dikkatle bakılması gerektiğini gösteren, yorulmak bilmeyen bir araştırma asistanıdır. Gelin bu asistanın nasıl çalıştığını inceleyelim.</p>

<p>``</p>

<h2 id="önce-görüntüden-metne-zorlu-ilk-adım">Önce görüntüden metne: Zorlu ilk adım</h2>

<p>Doğal dil işleme, görüntüler üzerinde değil, çoğunlukla metin temsilleri üzerinde çalışır. Bu nedenle taranmış belgeler önce yazıya aktarılmalıdır. Basılı metinlerde OCR, el yazmalarında ise HTR, yani el yazısı tanıma sistemleri kullanılır. Mürekkep lekeleri, eğik satırlar ve birbirine benzeyen harfler bu aşamada ciddi hata kaynaklarıdır. Tarihsel yazı sistemlerinde modern dil modellerinin başarısı doğrudan varsayılamaz; uzman tarafından doğrulanmış örneklerle ölçülmelidir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Güçlü olduğu alan</th>
      <th>Temel sınırlama</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>OCR</td>
      <td>Düzenli basılı belgeler</td>
      <td>El yazısında zorlanır</td>
    </tr>
    <tr>
      <td>HTR</td>
      <td>El yazması sayfalar</td>
      <td>Yazıcıya özgü eğitim gerekebilir</td>
    </tr>
    <tr>
      <td>İnsan transkripsiyonu</td>
      <td>Bağlamlı çözümleme</td>
      <td>Zaman ve uzmanlık ister</td>
    </tr>
  </tbody>
</table>

<p>Örneğin “liman” sözcüğü sürekli yanlış okunuyorsa, deniz ticaretinin arşivdeki görünürlüğü yapay olarak azalır. Dolayısıyla metin madenciliğinin güvenilirliği, veri hazırlığının güvenilirliğine bağlıdır.</p>

<h2 id="temizlemek-geçmişi-silmek-değildir">Temizlemek, geçmişi silmek değildir</h2>

<p>Her belgeye kimlik, tarih, arşiv referansı ve mümkünse yazıcı bilgisi ekleyin. Özgün görüntüyü ve ham transkripsiyonu koruyun; analiz için ayrı bir normalleştirilmiş sürüm üretin. Böylece araştırmacı, modelin kullandığı sözcüğün aslına geri dönebilir.</p>

<p>Tarihsel yazım çeşitliliği özellikle önemlidir. Aynı yer farklı dönemlerde farklı adlarla anılabilir; aynı sözcük birkaç yazımla karşınıza çıkabilir. Bunları birleştirmek sayımları iyileştirirken dönemsel farklılıkları silebilir. Bu yüzden dönüşümleri belgelenmiş bir sözlükle uygulayın. Modern Türkçe durak sözcüklerini de körlemesine kullanmayın: Arşivdeki kalıplaşmış ifadeler bazen belgenin türünü veya idari ilişkileri anlatır.</p>

<h2 id="sözcüklerden-örüntülere">Sözcüklerden örüntülere</h2>

<p>İlk adım, belgeleri sayısal vektörlere dönüştürmektir. TF-IDF, bir belgede sık görülen fakat koleksiyonun tamamında daha seyrek bulunan sözcüklere yüksek ağırlık verir. Yaygın bir yumuşatılmış tanım şöyledir:</p>

\[\mathrm{tfidf}(t,d)=\mathrm{tf}(t,d)\left[\log\frac{N+1}{\mathrm{df}(t)+1}+1\right]\]

<p>Burada $N$ belge sayısı, $\mathrm{df}(t)$ ise sözcüğün geçtiği belge sayısıdır. Böylece her yerde bulunan bir hitap ifadesi yerine, belirli belgeleri ayırt eden “gümrük” gibi sözcükler öne çıkabilir. Ancak yüksek ağırlık, tarihsel önemle aynı şey değildir: Nadir bir tanıma hatası da yüksek puan alabilir.</p>

<p>Konu modelleme için NMF kullanılabilir. Belge-sözcük matrisi yaklaşık olarak $X \approx WH$ biçiminde ayrıştırılır. $W$, belgelerin konu ağırlıklarını; $H$ ise konuların sözcük ağırlıklarını temsil eder.</p>

<h2 id="python-ile-küçük-bir-keşif">Python ile küçük bir keşif</h2>

<p>Aşağıdaki örnek, Latin harflerine aktarılmış, onlarca belge içeren bir koleksiyon varsayar. CSV dosyasının <code class="language-plaintext highlighter-rouge">belge_id</code>, <code class="language-plaintext highlighter-rouge">tarih</code> ve <code class="language-plaintext highlighter-rouge">metin</code> sütunları bulunmalıdır. Kod, Türkçeye uygun küçük harf dönüşümü yapar ve dört aday konu çıkarır:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">unicodedata</span>
<span class="kn">import</span> <span class="n">pandas</span> <span class="k">as</span> <span class="n">pd</span>
<span class="kn">from</span> <span class="n">sklearn.feature_extraction.text</span> <span class="kn">import</span> <span class="n">TfidfVectorizer</span>
<span class="kn">from</span> <span class="n">sklearn.decomposition</span> <span class="kn">import</span> <span class="n">NMF</span>

 <span class="k">def</span> <span class="nf">normalize</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
    <span class="n">text</span> <span class="o">=</span> <span class="n">unicodedata</span><span class="p">.</span><span class="nf">normalize</span><span class="p">(</span><span class="sh">"</span><span class="s">NFC</span><span class="sh">"</span><span class="p">,</span> <span class="n">text</span><span class="p">)</span>
    <span class="n">text</span> <span class="o">=</span> <span class="n">text</span><span class="p">.</span><span class="nf">replace</span><span class="p">(</span><span class="sh">"</span><span class="s">İ</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">i</span><span class="sh">"</span><span class="p">).</span><span class="nf">replace</span><span class="p">(</span><span class="sh">"</span><span class="s">I</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">ı</span><span class="sh">"</span><span class="p">)</span>
    <span class="k">return</span> <span class="sh">"</span><span class="s"> </span><span class="sh">"</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="n">text</span><span class="p">.</span><span class="nf">lower</span><span class="p">().</span><span class="nf">split</span><span class="p">())</span>
</code></pre></div></div>

<p>Fonksiyon tanımını girintisiz kullanarak analiz akışını şöyle tamamlayın:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">normalize</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
    <span class="n">text</span> <span class="o">=</span> <span class="n">unicodedata</span><span class="p">.</span><span class="nf">normalize</span><span class="p">(</span><span class="sh">"</span><span class="s">NFC</span><span class="sh">"</span><span class="p">,</span> <span class="n">text</span><span class="p">)</span>
    <span class="n">text</span> <span class="o">=</span> <span class="n">text</span><span class="p">.</span><span class="nf">replace</span><span class="p">(</span><span class="sh">"</span><span class="s">İ</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">i</span><span class="sh">"</span><span class="p">).</span><span class="nf">replace</span><span class="p">(</span><span class="sh">"</span><span class="s">I</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">ı</span><span class="sh">"</span><span class="p">)</span>
    <span class="k">return</span> <span class="sh">"</span><span class="s"> </span><span class="sh">"</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="n">text</span><span class="p">.</span><span class="nf">lower</span><span class="p">().</span><span class="nf">split</span><span class="p">())</span>

<span class="n">belgeler</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="nf">read_csv</span><span class="p">(</span><span class="sh">"</span><span class="s">arsiv.csv</span><span class="sh">"</span><span class="p">).</span><span class="nf">dropna</span><span class="p">(</span><span class="n">subset</span><span class="o">=</span><span class="p">[</span><span class="sh">"</span><span class="s">metin</span><span class="sh">"</span><span class="p">])</span>
<span class="n">vectorizer</span> <span class="o">=</span> <span class="nc">TfidfVectorizer</span><span class="p">(</span>
    <span class="n">preprocessor</span><span class="o">=</span><span class="n">normalize</span><span class="p">,</span>
    <span class="n">ngram_range</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span>
    <span class="n">min_df</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>
    <span class="n">max_df</span><span class="o">=</span><span class="mf">0.95</span>
<span class="p">)</span>
<span class="n">X</span> <span class="o">=</span> <span class="n">vectorizer</span><span class="p">.</span><span class="nf">fit_transform</span><span class="p">(</span><span class="n">belgeler</span><span class="p">[</span><span class="sh">"</span><span class="s">metin</span><span class="sh">"</span><span class="p">])</span>
<span class="n">model</span> <span class="o">=</span> <span class="nc">NMF</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">init</span><span class="o">=</span><span class="sh">"</span><span class="s">nndsvda</span><span class="sh">"</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">W</span> <span class="o">=</span> <span class="n">model</span><span class="p">.</span><span class="nf">fit_transform</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="n">kelimeler</span> <span class="o">=</span> <span class="n">vectorizer</span><span class="p">.</span><span class="nf">get_feature_names_out</span><span class="p">()</span>

<span class="k">for</span> <span class="n">konu</span><span class="p">,</span> <span class="n">agirliklar</span> <span class="ow">in</span> <span class="nf">enumerate</span><span class="p">(</span><span class="n">model</span><span class="p">.</span><span class="n">components_</span><span class="p">):</span>
    <span class="n">indeksler</span> <span class="o">=</span> <span class="n">agirliklar</span><span class="p">.</span><span class="nf">argsort</span><span class="p">()[</span><span class="o">-</span><span class="mi">8</span><span class="p">:][::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
    <span class="nf">print</span><span class="p">(</span><span class="n">konu</span><span class="p">,</span> <span class="sh">"</span><span class="s">, </span><span class="sh">"</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="n">kelimeler</span><span class="p">[</span><span class="n">indeksler</span><span class="p">]))</span>
</code></pre></div></div>

<p>İkili sözcük grupları, “gümrük vergisi” gibi ifadeleri yakalar. <code class="language-plaintext highlighter-rouge">min_df</code>, tek belgede görülen gürültüyü azaltır; ancak nadir tarihsel terimleri de dışlayabilir. Dört konu yalnızca başlangıç tercihidir, tarihsel gerçekliğin sayısı değildir.</p>

<h2 id="sonuçları-tarihçi-gibi-sorgulamak">Sonuçları tarihçi gibi sorgulamak</h2>

<p>Bir konu “vergi, borç, tahsil” sözcüklerini içeriyorsa hemen “ekonomik kriz” etiketi yapıştırmayın. Önce yüksek ağırlıklı belgeleri okuyun. Zaman içindeki değişimleri incelerken belge sayısını, türünü ve arşivde korunma koşullarını hesaba katın. Bir yıldaki artış, gerçek bir toplumsal dönüşümden değil, daha fazla belgenin günümüze ulaşmasından kaynaklanabilir.</p>

<p>Varlık tanıma ile kişi ve yer ağları da kurulabilir; fakat aynı adın farklı kişilere ait olması ilişkileri karıştırabilir. Değerlendirmede uzmanların işaretlediği örneklerden yararlanın, kopya belgeleri eğitim ve test kümelerine dağıtmayın. Ham veriyi, dönüşümleri ve model ayarlarını kaydedin. En iyi sonuç, algoritmanın önerdiği örüntüyü özgün belgeye dönerek doğrulamaktır: Bilgisayar ipucunu bulur, tarihçi anlamını tartışır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="metin madenciliği" /><category term="doğal dil işleme" /><category term="dijital beşeri bilimler" /><category term="tarihi belgeler" /><category term="konu modelleme" /><category term="python" /><summary type="html"><![CDATA[Tozlu bir arşivdeki binlerce mektubu düşünün: değişen ticaret yolları, tekrar eden şikâyetler, unutulmuş yer adları… Hepsini tek tek okumak yıllar sürebilir. Metin madenciliği, bu belgeleri tarihçinin yerine yorumlayan sihirli bir makine değildir; nerelere dikkatle bakılması gerektiğini gösteren, yorulmak bilmeyen bir araştırma asistanıdır. Gelin bu asistanın nasıl çalıştığını inceleyelim.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/arsivlerin-fisiltisini-duymak-56.png" /><media:content medium="image" url="https://program.sonsuz.us/img/arsivlerin-fisiltisini-duymak-56.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Dağıtık Sistemlerde Komuta Kontrol: Çok Araç, Tek Plan</title><link href="https://program.sonsuz.us/posts/dagitik-sistemlerde-komuta-kontrol-cok-arac-tek-plan/" rel="alternate" type="text/html" title="Dağıtık Sistemlerde Komuta Kontrol: Çok Araç, Tek Plan" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/dagitik-sistemlerde-komuta-kontrol-cok-arac-tek-plan</id><content type="html" xml:base="https://program.sonsuz.us/posts/dagitik-sistemlerde-komuta-kontrol-cok-arac-tek-plan/"><![CDATA[<p>Bir depoda onlarca taşıma robotunun aynı anda çalıştığını düşünün: biri paket topluyor, diğeri şarj oluyor, üçüncüsü koridorda bekliyor. Hepsine ayrı ayrı bağırmak yerine ortak bir plan gerekiyor. Dağıtık sistemlerde komuta kontrol mimarisi, bağımsız araçları merkezi hedefler etrafında koordine eder. Ancak merkez, her tekerleğin dönüşünü yönetmek zorunda değildir!</p>

<p>``</p>

<h2 id="merkezi-komuta-gerçekte-ne-demek">Merkezi Komuta Gerçekte Ne Demek?</h2>

<p>Merkezileşme, bütün yazılımın tek bilgisayarda çalışması değil, karar yetkisinin mantıksal olarak belirli bir yerde toplanmasıdır. Komuta katmanı görevleri dağıtır; araçlar görevleri yerel koşullara göre yürütür ve sonuçlarını bildirir.</p>

<p>Bu ayrım iki kontrol döngüsü oluşturur: merkezde daha yavaş görev planlama, araçta daha hızlı hareket ve güvenlik kontrolü. Ağ bağlantısındaki gecikme, aracın engelden kaçınmasını bekletmemelidir. Orkestra şefi tempoyu belirler; kemanın her yay hareketini uzaktan yapmaz.</p>

<h2 id="mimariyi-katmanlara-ayıralım">Mimariyi Katmanlara Ayıralım</h2>

<p>İşlevlerin ayrılması, hem testleri kolaylaştırır hem de bir katmandaki sorunun diğerlerine yayılmasını sınırlar:</p>

<ul>
  <li><strong>Komuta katmanı:</strong> Hedefleri, öncelikleri ve görevlerin yaşam döngüsünü yönetir. Örneğin acil teslimatı sıradan taşımanın önüne alır.</li>
  <li><strong>Koordinasyon katmanı:</strong> Araç uygunluğunu, batarya seviyesini ve paylaşılan kaynakları değerlendirir. Aynı dar koridoru iki araca eşzamanlı ayırmaz.</li>
  <li><strong>Araç katmanı:</strong> Komutları doğrular, yerel kontrolü yürütür ve durum raporlar. Bağlantı kaybında önceden tanımlanmış güvenli davranışa geçer.</li>
</ul>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Karar noktası</th>
      <th>Güçlü tarafı</th>
      <th>Temel riski</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Merkezi</td>
      <td>Tek mantıksal otorite</td>
      <td>Küresel optimizasyon</td>
      <td>Merkeze bağımlılık</td>
    </tr>
    <tr>
      <td>Hiyerarşik</td>
      <td>Merkez ve bölgesel yöneticiler</td>
      <td>Ölçeklenebilirlik</td>
      <td>Katmanlar arası gecikme</td>
    </tr>
    <tr>
      <td>Dağıtık</td>
      <td>Araçlar arası uzlaşma</td>
      <td>Yerel dayanıklılık</td>
      <td>Koordinasyon karmaşıklığı</td>
    </tr>
  </tbody>
</table>

<p>Seçim yalnızca araç sayısına bağlı değildir. Görevlerin birbirine bağımlılığı, ağ kalitesi ve güvenlik gereksinimleri de belirleyicidir.</p>

<h2 id="ağ-güvenilmezse-plan-ne-olur">Ağ Güvenilmezse Plan Ne Olur?</h2>

<p>Bir komutun gecikme bütçesini kabaca şöyle yazabiliriz:</p>

\[T_{tepki} = T_{ag} + T_{kuyruk} + T_{islem}\]

<p>Toplam süre görevin toleransını aşıyorsa, eski komutu çalıştırmak doğru değildir. Bu yüzden komutlarda kimlik, sıra numarası ve geçerlilik süresi bulunmalıdır. Kalp atışı mesajları bağlantı durumunu izlemeye yardım eder; fakat sessizlik, aracın kesinlikle bozulduğunu kanıtlamaz.</p>

<p>Komuta servisi yedeklenebilir. Yalnız iki sunucunun aynı anda lider olduğunu düşünmesi, yani <strong>split-brain</strong>, çelişkili emirler üretir. Çoğunluk tabanlı uzlaşma ve uygun noktalarda doğrulanan liderlik belirteçleri bu riski azaltır. Çökme tipi $f$ arızaya dayanabilen tipik çoğunluk düzeni için:</p>

\[n &gt;= 2f + 1\]

<p>Ağ bölünmesinde her tarafta yeni görev kabul etmek yerine bazı işlemleri durdurmak gerekebilir. Erişilebilirlik ile tutarlılık arasındaki tercih, güvenlik gereksinimine göre yapılmalıdır.</p>

<h2 id="python-ile-küçük-bir-koordinasyon-deneyi">Python ile Küçük Bir Koordinasyon Deneyi</h2>

<p>Aşağıdaki simülasyon iki araca kuyruk üzerinden görev gönderir. Her araç, eskimiş veya yinelenen sıra numaralarını ve geçerlilik süresi dolmuş komutları eler:</p>

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

<span class="k">async</span> <span class="k">def</span> <span class="nf">vehicle</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">inbox</span><span class="p">):</span>
    <span class="n">last_seq</span> <span class="o">=</span> <span class="mi">0</span>
    <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
        <span class="n">command</span> <span class="o">=</span> <span class="k">await</span> <span class="n">inbox</span><span class="p">.</span><span class="nf">get</span><span class="p">()</span>
        <span class="k">if</span> <span class="n">command</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
            <span class="k">return</span>
        <span class="k">if</span> <span class="n">command</span><span class="p">[</span><span class="sh">"</span><span class="s">seq</span><span class="sh">"</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="n">last_seq</span><span class="p">:</span>
            <span class="k">continue</span>
        <span class="k">if</span> <span class="n">time</span><span class="p">.</span><span class="nf">monotonic</span><span class="p">()</span> <span class="o">&gt;</span> <span class="n">command</span><span class="p">[</span><span class="sh">"</span><span class="s">expires</span><span class="sh">"</span><span class="p">]:</span>
            <span class="k">continue</span>
        <span class="n">last_seq</span> <span class="o">=</span> <span class="n">command</span><span class="p">[</span><span class="sh">"</span><span class="s">seq</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="si">{</span><span class="n">name</span><span class="si">}</span><span class="s">: </span><span class="si">{</span><span class="n">command</span><span class="p">[</span><span class="sh">'</span><span class="s">task</span><span class="sh">'</span><span class="p">]</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
        <span class="k">await</span> <span class="n">asyncio</span><span class="p">.</span><span class="nf">sleep</span><span class="p">(</span><span class="mf">0.1</span><span class="p">)</span>

<span class="k">async</span> <span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
    <span class="n">inboxes</span> <span class="o">=</span> <span class="p">{</span><span class="n">n</span><span class="p">:</span> <span class="n">asyncio</span><span class="p">.</span><span class="nc">Queue</span><span class="p">()</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="p">(</span><span class="sh">"</span><span class="s">arac-1</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">arac-2</span><span class="sh">"</span><span class="p">)}</span>
    <span class="n">workers</span> <span class="o">=</span> <span class="p">[</span><span class="n">asyncio</span><span class="p">.</span><span class="nf">create_task</span><span class="p">(</span><span class="nf">vehicle</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">q</span><span class="p">))</span>
               <span class="k">for</span> <span class="n">n</span><span class="p">,</span> <span class="n">q</span> <span class="ow">in</span> <span class="n">inboxes</span><span class="p">.</span><span class="nf">items</span><span class="p">()]</span>
    <span class="n">tasks</span> <span class="o">=</span> <span class="p">[(</span><span class="sh">"</span><span class="s">arac-1</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">paket-topla</span><span class="sh">"</span><span class="p">),</span> <span class="p">(</span><span class="sh">"</span><span class="s">arac-2</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">sarj-ol</span><span class="sh">"</span><span class="p">)]</span>
    <span class="k">for</span> <span class="n">seq</span><span class="p">,</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">task</span><span class="p">)</span> <span class="ow">in</span> <span class="nf">enumerate</span><span class="p">(</span><span class="n">tasks</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
        <span class="k">await</span> <span class="n">inboxes</span><span class="p">[</span><span class="n">name</span><span class="p">].</span><span class="nf">put</span><span class="p">({</span>
            <span class="sh">"</span><span class="s">seq</span><span class="sh">"</span><span class="p">:</span> <span class="n">seq</span><span class="p">,</span> <span class="sh">"</span><span class="s">task</span><span class="sh">"</span><span class="p">:</span> <span class="n">task</span><span class="p">,</span>
            <span class="sh">"</span><span class="s">expires</span><span class="sh">"</span><span class="p">:</span> <span class="n">time</span><span class="p">.</span><span class="nf">monotonic</span><span class="p">()</span> <span class="o">+</span> <span class="mi">2</span>
        <span class="p">})</span>
    <span class="k">for</span> <span class="n">queue</span> <span class="ow">in</span> <span class="n">inboxes</span><span class="p">.</span><span class="nf">values</span><span class="p">():</span>
        <span class="k">await</span> <span class="n">queue</span><span class="p">.</span><span class="nf">put</span><span class="p">(</span><span class="bp">None</span><span class="p">)</span>
    <span class="k">await</span> <span class="n">asyncio</span><span class="p">.</span><span class="nf">gather</span><span class="p">(</span><span class="o">*</span><span class="n">workers</span><span class="p">)</span>

<span class="n">asyncio</span><span class="p">.</span><span class="nf">run</span><span class="p">(</span><span class="nf">main</span><span class="p">())</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">asyncio</code>, araçların bekleme sırasında birbirini engellemeden ilerlemesini sağlar. Kuyruklar iletişim kanalını temsil eder; <code class="language-plaintext highlighter-rouge">None</code>, çalışanı kapatır. Buradaki saat yalnızca aynı süreçteki simülasyon için uygundur; makineler arasında doğrudan karşılaştırılamaz.</p>

<p>Örnek, teslim garantisi veya kalıcı hata kurtarma sağlamaz. Üretimde komut günlüğü, alındı ve tamamlandı bildirimleri, yeniden deneme ve idempotent işlemler gerekir. Bellekteki sıra numarası yeniden başlatmada kaybolduğu için tek başına yeterli değildir. Ayrıca zaman aşımı, burada yalnızca göreve başlamadan önce denetlenir.</p>

<h2 id="güvenlik-ve-gözlemlenebilirlik">Güvenlik ve Gözlemlenebilirlik</h2>

<p>Merkezi komuta güçlüdür; ele geçirilirse hata da merkezi olarak yayılabilir. Karşılıklı kimlik doğrulama, şifreli iletişim ve görev bazlı yetkilendirme uygulanmalıdır. Her komutun kim tarafından gönderildiği, hangi araçta kabul edildiği ve nasıl sonuçlandığı izlenebilmelidir.</p>

<p>Gecikme dağılımı, kuyruk uzunluğu ve başarısız görev oranı izlenmelidir. Kontrollü duruş gibi güvenli durumlar, araç türüne göre önceden doğrulanmalıdır. Bağlantı kesildiğinde aracın rastgele karar üretmesi, dayanıklılık değildir.</p>

<h2 id="sonuç-merkez-planlasın-araç-düşünsün">Sonuç: Merkez Planlasın, Araç Düşünsün</h2>

<p>İyi komuta kontrol mimarisi, ortak hedefleri merkezi olarak yönetirken hızlı ve güvenlik açısından kritik kararları yerelde tutar. Başarı, bütün araçların aynı anda hareket etmesi değil; gecikme, tekrar ve arıza altında bile birbirleriyle çelişmeden çalışmasıdır.</p>

<p><img src="/img/dagitik-sistemlerde-komuta-83.svg" alt="dagitik-sistemlerde-komuta-83" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="dağıtık-sistemler" /><category term="komuta-kontrol" /><category term="sistem-mimarisi" /><category term="python" /><category term="eşzamanlılık" /><summary type="html"><![CDATA[Bir depoda onlarca taşıma robotunun aynı anda çalıştığını düşünün: biri paket topluyor, diğeri şarj oluyor, üçüncüsü koridorda bekliyor. Hepsine ayrı ayrı bağırmak yerine ortak bir plan gerekiyor. Dağıtık sistemlerde komuta kontrol mimarisi, bağımsız araçları merkezi hedefler etrafında koordine eder. Ancak merkez, her tekerleğin dönüşünü yönetmek zorunda değildir!]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/dagitik-sistemlerde-komuta-83.png" /><media:content medium="image" url="https://program.sonsuz.us/img/dagitik-sistemlerde-komuta-83.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Dijital Delilin Mührü: Hash Doğrulama Mahkemede Ne Anlatır?</title><link href="https://program.sonsuz.us/posts/dijital-delilin-muhru-hash-dogrulama-mahkemede-ne-anlatir/" rel="alternate" type="text/html" title="Dijital Delilin Mührü: Hash Doğrulama Mahkemede Ne Anlatır?" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/dijital-delilin-muhru-hash-dogrulama-mahkemede-ne-anlatir</id><content type="html" xml:base="https://program.sonsuz.us/posts/dijital-delilin-muhru-hash-dogrulama-mahkemede-ne-anlatir/"><![CDATA[<p><img src="/img/dijital-delilin-muhru-49.svg" alt="dijital-delilin-muhru-49" /></p>

<p>Bir bilgisayardan çıkan dosyanın mahkeme salonuna ulaşana kadar değiştirilmediğini nasıl gösterirsiniz? “Vallahi dokunmadım” teknik rapor sayılmaz. Dijital adli bilişimde hash değerleri, delilin bütünlüğünü kontrol etmek için kullanılır. Ancak iş yalnızca uzun bir karakter dizisini hesaplamak değildir: güvenilir toplama, kayıt tutma ve teslim zinciri de aynı hikâyenin parçalarıdır.</p>

<p>``</p>

<h2 id="hash-dijital-parmak-izi-noter-değil">Hash: dijital parmak izi, noter değil</h2>

<p>Kriptografik hash fonksiyonu, değişken uzunluktaki veriyi sabit uzunlukta bir özete dönüştürür. SHA-256 için çıktı 256 bittir; genellikle 64 onaltılık karakterle gösterilir. Dosyadaki tek bitlik değişiklik bile çıktıyı büyük ölçüde farklılaştırır. Aynı veri, aynı algoritmayla her zaman aynı özeti üretir.</p>

<p>Toplama sırasında hesaplanan değer $h_0 = H(D_0)$, sonraki kontrolde hesaplanan değer ise $h_1 = H(D_1)$ olsun:</p>

\[h_0 = h_1\]

<p>Bu eşitlik, güvenilir başlangıç kaydı ve uygun algoritma kullanıldığında, karşılaştırılan baytların değişmediğine çok güçlü güvence sağlar. Matematiksel olarak farklı girdilerin aynı özeti üretmesi mümkündür; buna <strong>çakışma</strong> denir. Güvenlik, böyle bir çakışmayı bulmanın uygulanabilir olmamasına dayanır.</p>

<table>
  <thead>
    <tr>
      <th>Algoritma</th>
      <th style="text-align: right">Çıktı uzunluğu</th>
      <th>Adli kullanım açısından yaklaşım</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>MD5</td>
      <td style="text-align: right">128 bit</td>
      <td>Çakışma zayıflıkları nedeniyle tek başına tercih edilmez</td>
    </tr>
    <tr>
      <td>SHA-1</td>
      <td style="text-align: right">160 bit</td>
      <td>Yeni bütünlük kayıtlarında kullanılmaması önerilir</td>
    </tr>
    <tr>
      <td>SHA-256</td>
      <td style="text-align: right">256 bit</td>
      <td>Güncel ve yaygın bir tercih</td>
    </tr>
  </tbody>
</table>

<p>Önemli ayrım: Hash, dosyanın <strong>kim tarafından oluşturulduğunu</strong> veya içeriğinin <strong>doğru olduğunu</strong> kanıtlamaz. Yalnızca belirli bir referansla bütünlük karşılaştırmasına yardımcı olur.</p>

<h2 id="sağlam-bir-toplama-süreci-nasıl-kurulur">Sağlam bir toplama süreci nasıl kurulur?</h2>

<ol>
  <li><strong>Yetkiyi ve kapsamı belirleyin.</strong> İnceleme dayanağını, cihazı, seri numarasını, görevliyi ve işlem zamanını kaydedin. Gereksiz veri toplamaktan kaçının; kapsam dışına çıkmak teknik başarıyı hukuki soruna dönüştürebilir.</li>
  <li><strong>Kaynağı koruyun.</strong> Uygun durumlarda doğrulanmış yazma engelleyici kullanın. Canlı sistemler, şifreleme ve uçucu bellek farklı yöntemler gerektirebilir; yapılan müdahaleleri açıkça belgeleyin.</li>
  <li><strong>Adli kopya oluşturun.</strong> Gereksinime göre fiziksel imaj veya mantıksal toplama yapın. Kullanılan aracın sürümünü, ayarlarını, hataları ve okunamayan sektörleri rapora ekleyin. Fiziksel imaj tüm adreslenebilir alanı hedeflerken mantıksal toplama seçili dosya ve yapıları kapsar.</li>
  <li><strong>Doğru veriyi karşılaştırın.</strong> Ham imaj, kaynakla aynı bayt dizisini temsil ediyorsa özetler karşılaştırılabilir. E01 gibi kapsayıcıların dosya hash’i, içlerindeki disk verisinin hash’iyle aynı kavram değildir.</li>
  <li><strong>Başlangıç kaydını güvenceye alın.</strong> Hash değerini delil kimliği, zaman, algoritma ve görevli bilgisiyle ilişkilendirin. İmzalı kayıtlar, uygun zaman damgaları ve erişim kontrolleri kaydın sonradan değiştirilmesini zorlaştırır.</li>
  <li><strong>Her aktarımı belgeleyin.</strong> Kim, ne zaman, kimden teslim aldı? Depolama, kopyalama ve analiz öncesi kontrolleri kaydedin. İşte bu kayıt dizisi, delilin teslim zinciridir.</li>
</ol>

<h2 id="python-ile-büyük-dosyalarda-doğrulama">Python ile büyük dosyalarda doğrulama</h2>

<p>Aşağıdaki örnek dosyayı belleğe tamamen yüklemek yerine 1 MiB parçalarla okur. Güvenilir başlangıç kaydındaki <code class="language-plaintext highlighter-rouge">sha256</code> alanını yeniden hesaplanan değerle karşılaştırır. Örneği orijinal cihazda değil, uygun biçimde korunmuş ve yazmaya kapalı bir kopyada çalıştırın; dosyanın işlem sırasında değişmemesi gerekir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">hashlib</span>
<span class="kn">import</span> <span class="n">hmac</span>
<span class="kn">import</span> <span class="n">json</span>
<span class="kn">import</span> <span class="n">sys</span>
<span class="kn">from</span> <span class="n">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>


<span class="k">def</span> <span class="nf">sha256_file</span><span class="p">(</span><span class="n">path</span><span class="p">:</span> <span class="n">Path</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
    <span class="n">digest</span> <span class="o">=</span> <span class="n">hashlib</span><span class="p">.</span><span class="nf">sha256</span><span class="p">()</span>
    <span class="k">with</span> <span class="n">path</span><span class="p">.</span><span class="nf">open</span><span class="p">(</span><span class="sh">"</span><span class="s">rb</span><span class="sh">"</span><span class="p">)</span> <span class="k">as</span> <span class="n">stream</span><span class="p">:</span>
        <span class="k">for</span> <span class="n">block</span> <span class="ow">in</span> <span class="nf">iter</span><span class="p">(</span><span class="k">lambda</span><span class="p">:</span> <span class="n">stream</span><span class="p">.</span><span class="nf">read</span><span class="p">(</span><span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">),</span> <span class="sa">b</span><span class="sh">""</span><span class="p">):</span>
            <span class="n">digest</span><span class="p">.</span><span class="nf">update</span><span class="p">(</span><span class="n">block</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">digest</span><span class="p">.</span><span class="nf">hexdigest</span><span class="p">()</span>


<span class="n">image</span> <span class="o">=</span> <span class="nc">Path</span><span class="p">(</span><span class="n">sys</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="n">record</span> <span class="o">=</span> <span class="n">json</span><span class="p">.</span><span class="nf">loads</span><span class="p">(</span><span class="nc">Path</span><span class="p">(</span><span class="n">sys</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]).</span><span class="nf">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="sh">"</span><span class="s">utf-8</span><span class="sh">"</span><span class="p">))</span>
<span class="n">expected</span> <span class="o">=</span> <span class="n">record</span><span class="p">[</span><span class="sh">"</span><span class="s">sha256</span><span class="sh">"</span><span class="p">].</span><span class="nf">strip</span><span class="p">().</span><span class="nf">lower</span><span class="p">()</span>
<span class="n">actual</span> <span class="o">=</span> <span class="nf">sha256_file</span><span class="p">(</span><span class="n">image</span><span class="p">)</span>

<span class="k">if</span> <span class="ow">not</span> <span class="n">hmac</span><span class="p">.</span><span class="nf">compare_digest</span><span class="p">(</span><span class="n">expected</span><span class="p">,</span> <span class="n">actual</span><span class="p">):</span>
    <span class="k">raise</span> <span class="nc">SystemExit</span><span class="p">(</span><span class="sh">"</span><span class="s">UYARI: Hash değerleri uyuşmuyor!</span><span class="sh">"</span><span class="p">)</span>

<span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">Hash eşleşti:</span><span class="sh">"</span><span class="p">,</span> <span class="n">actual</span><span class="p">)</span>
</code></pre></div></div>

<p>Çalıştırma biçimi: <code class="language-plaintext highlighter-rouge">python dogrula.py disk.raw ilk_kayit.json</code>. Kayıt dosyası <code class="language-plaintext highlighter-rouge">sha256</code> anahtarını içermelidir. <code class="language-plaintext highlighter-rouge">hashlib</code> özeti hesaplar; <code class="language-plaintext highlighter-rouge">compare_digest</code> karşılaştırmayı yapar. Bu kod kayıt dosyasının dijital imzasını doğrulamaz. Dolayısıyla başlangıç değerinin güvenilirliği ayrı bir süreçle sağlanmalıdır. Çıktıyı, tarih ve delil kimliğiyle inceleme günlüğüne ekleyin.</p>

<h2 id="mahkemede-hash-neden-tek-başına-yetmez">Mahkemede hash neden tek başına yetmez?</h2>

<p>Bir kişi hem delili hem kayıtlı hash’i değiştirebiliyorsa, yeni bir hash hesaplayarak sahte bir eşleşme oluşturabilir. Ayrıca ilk hash alınmadan önce yapılan değişiklikler, sonraki eşleşmelerle ortaya çıkarılamaz. Referans noktasının güvenilirliği bu nedenle kritiktir.</p>

<p>Hash uyuşmazlığı da otomatik olarak kötü niyet demek değildir: aktarım hatası, bozuk ortam veya yanlış kapsam karşılaştırması araştırılmalıdır. Dosya içeriği hash’i, dosya adı ve harici dosya sistemi metaverisinin değişmediğini tek başına göstermez.</p>

<p>Delilin kabulü ülkeye, usule ve somut olaya bağlıdır; hash eşleşmesi otomatik geçerlilik bileti değildir. Güçlü sonuç, <strong>doğru toplama + korunmuş referans + belgelenmiş teslim zinciri + tekrarlanabilir doğrulama</strong> birleşimidir. Dijital mühür değerlidir; ama mührün kimin elinde olduğunu da bilmek gerekir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="dijital adli bilişim" /><category term="hash doğrulama" /><category term="sha256" /><category term="delil bütünlüğü" /><category term="teslim zinciri" /><category term="python" /><summary type="html"><![CDATA[Bir bilgisayardan çıkan dosyanın mahkeme salonuna ulaşana kadar değiştirilmediğini nasıl gösterirsiniz? “Vallahi dokunmadım” teknik rapor sayılmaz. Dijital adli bilişimde hash değerleri, delilin bütünlüğünü kontrol etmek için kullanılır. Ancak iş yalnızca uzun bir karakter dizisini hesaplamak değildir: güvenilir toplama, kayıt tutma ve teslim zinciri de aynı hikâyenin parçalarıdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/dijital-delilin-muhru-49.png" /><media:content medium="image" url="https://program.sonsuz.us/img/dijital-delilin-muhru-49.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Lojistikte Akıllı Planlama: Rotaları ve Kaynakları Algoritmalarla Yönetmek</title><link href="https://program.sonsuz.us/posts/lojistikte-akilli-planlama-rotalari-ve-kaynaklari-algoritmalarla-yonetmek/" rel="alternate" type="text/html" title="Lojistikte Akıllı Planlama: Rotaları ve Kaynakları Algoritmalarla Yönetmek" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/lojistikte-akilli-planlama-rotalari-ve-kaynaklari-algoritmalarla-yonetmek</id><content type="html" xml:base="https://program.sonsuz.us/posts/lojistikte-akilli-planlama-rotalari-ve-kaynaklari-algoritmalarla-yonetmek/"><![CDATA[<p>Bir kamyonun en kısa yolu bulması, lojistik probleminin yalnızca başlangıcıdır. Asıl mesele; doğru yükü, uygun araçla, sürücünün mesaisi bitmeden ve müşterinin kabul saatini kaçırmadan teslim etmektir. Üstelik depodaki yükleme kapısı da boş olmalıdır. Kısacası lojistik optimizasyonu, parçaları sürekli hareket eden bir Tetris oyunudur.</p>

<p><img src="/img/lojistikte-akilli-planlama-84.svg" alt="lojistikte-akilli-planlama-84" /></p>

<p>``</p>

<h2 id="önce-problemin-haritasını-çıkaralım">Önce Problemin Haritasını Çıkaralım</h2>

<p>Rota planlamasında müşteriler ve depolar bir grafın düğümlerini, yollar ise kenarlarını oluşturur. Her kenarın mesafe, süre veya parasal maliyet gibi ağırlıkları vardır. Ancak en kısa yol algoritması, tek başına bütün teslimatların hangi araçlara dağıtılacağını çözmez.</p>

<p>Burada <strong>Araç Rotalama Problemi</strong>, yani VRP devreye girer. Kapasiteli sürümü CVRP, teslimat saatlerini içeren sürümü ise VRPTW olarak bilinir. Kaynak planlama da bu modele araç uygunluğu, sürücü vardiyası ve depo kapasitesi gibi kararları ekler. Sonuç, birbirine bağlı rota ve çizelgeleme problemleridir.</p>

<table>
  <thead>
    <tr>
      <th>Problem</th>
      <th>Temel karar</th>
      <th>Önemli sınır</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>En kısa yol</td>
      <td>Hangi yoldan gidilmeli?</td>
      <td>Yol erişilebilirliği</td>
    </tr>
    <tr>
      <td>CVRP</td>
      <td>Müşterileri hangi araç gezmeli?</td>
      <td>Taşıma kapasitesi</td>
    </tr>
    <tr>
      <td>VRPTW</td>
      <td>Ziyaretler ne zaman yapılmalı?</td>
      <td>Teslimat aralığı</td>
    </tr>
    <tr>
      <td>Kaynak çizelgeleme</td>
      <td>Hangi kaynak ne zaman çalışmalı?</td>
      <td>Eşzamanlı kullanım</td>
    </tr>
  </tbody>
</table>

<h2 id="amaç-fonksiyonu-ve-kısıtlar">Amaç Fonksiyonu ve Kısıtlar</h2>

<p>Modelin amacı yalnızca kilometreyi azaltmak değildir. Daha az araç kullanmak, fazla mesaiyi önlemek ve hizmet kalitesini korumak da önemlidir. Basit bir maliyet modeli şöyle yazılabilir:</p>

\[\min C = \sum_k f_k y_k + \sum_{i,j,k} c_{ijk} x_{ijk}\]

<p>Burada $y_k$, araç kullanılıyorsa 1; $x_{ijk}$, araç ilgili bağlantıyı geçiyorsa 1 olur. $f_k$ sabit araç maliyetini, $c_{ijk}$ ise yolculuk maliyetini gösterir.</p>

<p>Kapasite için $\sum_i q_i z_{ik} \le Q_k$ gerekir. $z_{ik}$ müşteri atamasını, $q_i$ talebi belirtir. Ayrıca her müşteri atanmalı, araç akışı korunmalı ve depodan kopuk alt turlar engellenmelidir. Zaman pencereleri, servis süreleri ve vardiyalar da fizibiliteyi belirler. Sert kısıtlar ihlal edilemez; gecikme cezası ancak işletme gecikmeye izin veriyorsa kullanılmalıdır.</p>

<h2 id="hangi-algoritma-ne-zaman">Hangi Algoritma, Ne Zaman?</h2>

<p>Karma tamsayılı programlama, kararları ikili değişkenlerle ifade eder. Dal-sınır ve kesme düzlemleri gibi yöntemler, uygun ölçekteki modellerde optimal çözüm veya kanıtlanabilir bir optimalite açığı sunabilir. Büyük örneklerde ise süre sınırına ulaşmak mümkündür.</p>

<p>Bu nedenle pratik sistemler sıklıkla sezgisellerden yararlanır. En ucuz ekleme hızlı bir başlangıç üretir; 2-opt rota içindeki bağlantıları değiştirir. Tabu arama ve büyük komşuluk araması, müşterileri taşıyarak daha geniş çözüm alanlarını araştırır. Özellikle büyük komşuluk araması, planın bir kısmını söküp yeniden kurar: Düzenli bir dağıtım operasyonunda kontrollü bir “yeniden yerleştirme” çalışması gibi düşünülebilir.</p>

<h2 id="python-ile-kapasite-ve-vardiya-kontrollü-ekleme">Python ile Kapasite ve Vardiya Kontrollü Ekleme</h2>

<p>Aşağıdaki örnek, iki araca müşterileri yerleştirir. Mesafeler yerine dakika cinsinden yolculuk süreleri kullanılır; her teslimat beş dakika sürer.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">travel</span> <span class="o">=</span> <span class="p">[</span>
    <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="mi">15</span><span class="p">,</span> <span class="mi">30</span><span class="p">],</span>
    <span class="p">[</span><span class="mi">20</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">18</span><span class="p">,</span> <span class="mi">22</span><span class="p">],</span>
    <span class="p">[</span><span class="mi">25</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">15</span><span class="p">],</span>
    <span class="p">[</span><span class="mi">15</span><span class="p">,</span> <span class="mi">18</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">20</span><span class="p">],</span>
    <span class="p">[</span><span class="mi">30</span><span class="p">,</span> <span class="mi">22</span><span class="p">,</span> <span class="mi">15</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
<span class="p">]</span>
<span class="n">demand</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="n">capacity</span><span class="p">,</span> <span class="n">shift</span><span class="p">,</span> <span class="n">service</span> <span class="o">=</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">5</span>
<span class="n">routes</span> <span class="o">=</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">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">2</span><span class="p">)]</span>

<span class="k">def</span> <span class="nf">duration</span><span class="p">(</span><span class="n">route</span><span class="p">):</span>
    <span class="n">driving</span> <span class="o">=</span> <span class="nf">sum</span><span class="p">(</span><span class="n">travel</span><span class="p">[</span><span class="n">a</span><span class="p">][</span><span class="n">b</span><span class="p">]</span> <span class="k">for</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="ow">in</span> <span class="nf">zip</span><span class="p">(</span><span class="n">route</span><span class="p">,</span> <span class="n">route</span><span class="p">[</span><span class="mi">1</span><span class="p">:]))</span>
    <span class="k">return</span> <span class="n">driving</span> <span class="o">+</span> <span class="n">service</span> <span class="o">*</span> <span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">route</span><span class="p">)</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span>

<span class="k">for</span> <span class="n">customer</span> <span class="ow">in</span> <span class="nf">sorted</span><span class="p">(</span><span class="nf">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">5</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">c</span><span class="p">:</span> <span class="o">-</span><span class="n">demand</span><span class="p">[</span><span class="n">c</span><span class="p">]):</span>
    <span class="n">options</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">for</span> <span class="n">vehicle</span><span class="p">,</span> <span class="n">route</span> <span class="ow">in</span> <span class="nf">enumerate</span><span class="p">(</span><span class="n">routes</span><span class="p">):</span>
        <span class="k">if</span> <span class="nf">sum</span><span class="p">(</span><span class="n">demand</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">route</span><span class="p">)</span> <span class="o">+</span> <span class="n">demand</span><span class="p">[</span><span class="n">customer</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">capacity</span><span class="p">:</span>
            <span class="k">continue</span>
        <span class="k">for</span> <span class="n">position</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="nf">len</span><span class="p">(</span><span class="n">route</span><span class="p">)):</span>
            <span class="n">candidate</span> <span class="o">=</span> <span class="n">route</span><span class="p">[:</span><span class="n">position</span><span class="p">]</span> <span class="o">+</span> <span class="p">[</span><span class="n">customer</span><span class="p">]</span> <span class="o">+</span> <span class="n">route</span><span class="p">[</span><span class="n">position</span><span class="p">:]</span>
            <span class="k">if</span> <span class="nf">duration</span><span class="p">(</span><span class="n">candidate</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="n">shift</span><span class="p">:</span>
                <span class="n">extra</span> <span class="o">=</span> <span class="nf">duration</span><span class="p">(</span><span class="n">candidate</span><span class="p">)</span> <span class="o">-</span> <span class="nf">duration</span><span class="p">(</span><span class="n">route</span><span class="p">)</span>
                <span class="n">options</span><span class="p">.</span><span class="nf">append</span><span class="p">((</span><span class="n">extra</span><span class="p">,</span> <span class="n">vehicle</span><span class="p">,</span> <span class="n">candidate</span><span class="p">))</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">options</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">Ekleme başarısız; yeniden planlama gerekli.</span><span class="sh">"</span><span class="p">)</span>
    <span class="n">_</span><span class="p">,</span> <span class="n">vehicle</span><span class="p">,</span> <span class="n">candidate</span> <span class="o">=</span> <span class="nf">min</span><span class="p">(</span><span class="n">options</span><span class="p">)</span>
    <span class="n">routes</span><span class="p">[</span><span class="n">vehicle</span><span class="p">]</span> <span class="o">=</span> <span class="n">candidate</span>

<span class="nf">print</span><span class="p">(</span><span class="n">routes</span><span class="p">)</span>
</code></pre></div></div>

<p>Depo, <code class="language-plaintext highlighter-rouge">0</code> ile temsil edilir. Algoritma büyük talepleri önce ele alır ve uygulanabilir seçeneklerden süreyi en az artıranı seçer. Depoya dönüş de vardiya hesabına dahildir. Ancak bu açgözlü yaklaşım optimal değildir; ekleme başarısızlığı, problemin çözümsüz olduğunu kanıtlamaz. Örnek müşteri zaman pencerelerini modellemez; bunlar için varış, bekleme ve servis başlangıcı ayrıca hesaplanmalıdır.</p>

<h2 id="rotadan-operasyona-geçiş">Rotadan Operasyona Geçiş</h2>

<p>İyi rotalar, kötü kaynak çizelgesiyle depoda kuyruk oluşturabilir. Tek yükleme kapısında aynı anda iki araç çalışamaz. Bu nedenle yükleme bitişleri, araç çıkışları ve sürücü uygunluğu birlikte değerlendirilmelidir. Soğuk zincir veya araç türü gibi uyumluluk koşulları da müşteri atamalarını sınırlar.</p>

<p>Operasyon başladığında trafik ve yeni siparişler planı değiştirir. Yuvarlanan ufuk yaklaşımı, yakın kararları sabitleyip kalan işleri güncel verilerle yeniden optimize eder. Başarıyı yalnızca kilometreyle değil; toplam maliyet, zamanında teslimat, kaynak kullanım oranı ve planın değişken koşullara dayanıklılığıyla ölçmek gerekir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="lojistik" /><category term="rota optimizasyonu" /><category term="kaynak planlama" /><category term="tedarik zinciri" /><category term="algoritmalar" /><summary type="html"><![CDATA[Bir kamyonun en kısa yolu bulması, lojistik probleminin yalnızca başlangıcıdır. Asıl mesele; doğru yükü, uygun araçla, sürücünün mesaisi bitmeden ve müşterinin kabul saatini kaçırmadan teslim etmektir. Üstelik depodaki yükleme kapısı da boş olmalıdır. Kısacası lojistik optimizasyonu, parçaları sürekli hareket eden bir Tetris oyunudur.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/lojistikte-akilli-planlama-84.png" /><media:content medium="image" url="https://program.sonsuz.us/img/lojistikte-akilli-planlama-84.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Soğuk Zincirin Dijital Nöbetçileri: IoT Sensörleriyle Anlık Takip</title><link href="https://program.sonsuz.us/posts/soguk-zincirin-dijital-nobetcileri-iot-sensorleriyle-anlik-takip/" rel="alternate" type="text/html" title="Soğuk Zincirin Dijital Nöbetçileri: IoT Sensörleriyle Anlık Takip" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/soguk-zincirin-dijital-nobetcileri-iot-sensorleriyle-anlik-takip</id><content type="html" xml:base="https://program.sonsuz.us/posts/soguk-zincirin-dijital-nobetcileri-iot-sensorleriyle-anlik-takip/"><![CDATA[<p>Bir kamyon dolusu yoğurt veya sıcaklığa hassas ilaç düşünün: Yolculuk sorunsuz görünürken açık kalan bir kapı bütün hikâyeyi değiştirebilir. Soğuk zincir takibi, ürünün yalnızca teslimatta değil, yolculuk boyunca uygun koşullarda kaldığını izler. IoT sensörleri burada dijital nöbetçi gibi çalışır: Ölçer, haber verir ve sorun büyümeden müdahale fırsatı sunar.</p>

<p>``</p>

<h2 id="önce-teori-soğuk-zincir-neyi-korur">Önce teori: Soğuk zincir neyi korur?</h2>

<p>Sıcaklık, gıdalardaki mikrobiyal gelişimi ve ilaçların kimyasal kararlılığını etkileyebilir. Ancak bütün ürünlerin aynı sıcaklığı sevdiğini varsaymak hatadır. Bazı ürünler donmaya, bazıları ısınmaya duyarlıdır. Kabul aralığı; üretici talimatları, ürün özellikleri ve ilgili taşıma prosedürleri üzerinden belirlenmelidir. Örneğin aşağıdaki kodda kullanılan 2–8 °C aralığı, yalnızca bu aralık için tanımlanmış örnek bir ürün profiline aittir.</p>

<p>Temel koşul $T_{min} \le T(t) \le T_{max}$ şeklindedir. Burada sıcaklık, zamanın bir fonksiyonudur. Tek bir uygunsuz ölçüm önemlidir; fakat sapmanın süresi, büyüklüğü ve tekrarlanması da değerlendirilmelidir. Kısa bir yükseliş ile saatler süren sıcaklık ihlali aynı olay değildir. Yine de herhangi bir tolerans süresi, yazılımcının keyfine göre değil, onaylanmış ürün prosedürüne göre seçilmelidir.</p>

<h2 id="sensörden-ekrana-verinin-yolculuğu">Sensörden ekrana: Verinin yolculuğu</h2>

<p>Tipik mimaride sıcaklık probu bir mikrodenetleyiciye bağlanır. Cihaz ölçümleri zaman damgası, sensör kimliği ve sevkiyat numarasıyla paketler. BLE veya LoRa bağlantısı veriyi ağ geçidine, hücresel bağlantı ise sunucuya taşıyabilir. MQTT üzerinden gelen mesajlar zaman serisi veritabanına yazılır; kural motoru gerektiğinde sürücüyü ve operasyon ekibini bilgilendirir.</p>

<p>Sensörün konumu kritik önemdedir: Soğutucu çıkışındaki hava sıcaklığı, kutuların içindeki ürün sıcaklığıyla aynı değildir. Yerleşim, sıcaklık haritalamasıyla doğrulanmalıdır. Kalibrasyon, ölçüm belirsizliği ve probun tepki süresi de hesaba katılır; hızlı haberleşme, yavaş tepki veren sensörü sihirli biçimde hızlandırmaz.</p>

<table>
  <thead>
    <tr>
      <th>Durum</th>
      <th>Tespit yaklaşımı</th>
      <th>Operasyonel karşılık</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Sıcaklık sınırı aşıldı</td>
      <td>Ürün profiliyle karşılaştırma</td>
      <td>Sapma kaydı oluşturma</td>
    </tr>
    <tr>
      <td>Sapma uzadı</td>
      <td>Ardışık ölçümlerin süresi</td>
      <td>Onaylı kurala göre alarm</td>
    </tr>
    <tr>
      <td>Ölçüm gelmiyor</td>
      <td>Beklenen aralık kontrolü</td>
      <td>Telemetri kaybı uyarısı</td>
    </tr>
    <tr>
      <td>Bağlantı kesildi</td>
      <td>Yerel tampon ve yeniden gönderim</td>
      <td>Geçmiş kayıtları tamamlama</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/soguk-zincirin-dijital-87.svg" alt="soguk-zincirin-dijital-87" /></p>

<h2 id="i̇hlali-nasıl-yakalarız">İhlali nasıl yakalarız?</h2>

<p>Bir kural motoru, ölçümü yalnızca eşikle karşılaştırmakla yetinmez. Ölçümün geçerli olup olmadığını, hangi zamanda alındığını ve önceki kayıtla arasındaki boşluğu denetler. Sapma süresi $\Delta t = t_{son} - t_{ilk}$ olarak hesaplanabilir. Ancak seyrek örnekleme nedeniyle bu değer, kesintisiz fiziksel ihlalin kesin kanıtı değil, gözlenen sapmanın süre tahminidir.</p>

<p>Aşağıdaki Python üreteci, zaman sıralı ve önceden doğrulanmış ölçümleri işler. Aynı yöndeki sapma belirlenen süreyi aşınca tek alarm üretir; uzun veri boşluğunda süre takibini sıfırlar. Süre parametresi yalnızca gösterim amaçlıdır.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">izle</span><span class="p">(</span><span class="n">okumalar</span><span class="p">,</span> <span class="n">alt</span><span class="o">=</span><span class="mf">2.0</span><span class="p">,</span> <span class="n">ust</span><span class="o">=</span><span class="mf">8.0</span><span class="p">,</span> <span class="n">sure</span><span class="o">=</span><span class="mi">120</span><span class="p">,</span> <span class="n">bosluk</span><span class="o">=</span><span class="mi">90</span><span class="p">):</span>
    <span class="n">onceki</span> <span class="o">=</span> <span class="n">baslangic</span> <span class="o">=</span> <span class="n">taraf</span> <span class="o">=</span> <span class="bp">None</span>
    <span class="n">bildirildi</span> <span class="o">=</span> <span class="bp">False</span>

    <span class="k">for</span> <span class="n">zaman</span><span class="p">,</span> <span class="n">sicaklik</span> <span class="ow">in</span> <span class="n">okumalar</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">onceki</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">:</span>
            <span class="n">fark</span> <span class="o">=</span> <span class="p">(</span><span class="n">zaman</span> <span class="o">-</span> <span class="n">onceki</span><span class="p">).</span><span class="nf">total_seconds</span><span class="p">()</span>
            <span class="k">if</span> <span class="n">fark</span> <span class="o">&lt;=</span> <span class="mi">0</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">Zamanlar artan sırada olmalı</span><span class="sh">"</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">fark</span> <span class="o">&gt;</span> <span class="n">bosluk</span><span class="p">:</span>
                <span class="nf">yield </span><span class="p">(</span><span class="sh">"</span><span class="s">veri_boslugu</span><span class="sh">"</span><span class="p">,</span> <span class="n">zaman</span><span class="p">)</span>
                <span class="n">baslangic</span> <span class="o">=</span> <span class="n">taraf</span> <span class="o">=</span> <span class="bp">None</span>
                <span class="n">bildirildi</span> <span class="o">=</span> <span class="bp">False</span>
        <span class="n">onceki</span> <span class="o">=</span> <span class="n">zaman</span>

        <span class="n">yeni</span> <span class="o">=</span> <span class="sh">"</span><span class="s">alt</span><span class="sh">"</span> <span class="k">if</span> <span class="n">sicaklik</span> <span class="o">&lt;</span> <span class="n">alt</span> <span class="nf">else </span><span class="p">(</span>
            <span class="sh">"</span><span class="s">ust</span><span class="sh">"</span> <span class="k">if</span> <span class="n">sicaklik</span> <span class="o">&gt;</span> <span class="n">ust</span> <span class="k">else</span> <span class="bp">None</span>
        <span class="p">)</span>
        <span class="k">if</span> <span class="n">yeni</span> <span class="o">!=</span> <span class="n">taraf</span><span class="p">:</span>
            <span class="n">taraf</span> <span class="o">=</span> <span class="n">yeni</span>
            <span class="n">baslangic</span> <span class="o">=</span> <span class="n">zaman</span> <span class="k">if</span> <span class="n">yeni</span> <span class="k">else</span> <span class="bp">None</span>
            <span class="n">bildirildi</span> <span class="o">=</span> <span class="bp">False</span>

        <span class="k">if</span> <span class="n">baslangic</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">bildirildi</span><span class="p">:</span>
            <span class="n">gecen</span> <span class="o">=</span> <span class="p">(</span><span class="n">zaman</span> <span class="o">-</span> <span class="n">baslangic</span><span class="p">).</span><span class="nf">total_seconds</span><span class="p">()</span>
            <span class="k">if</span> <span class="n">gecen</span> <span class="o">&gt;=</span> <span class="n">sure</span><span class="p">:</span>
                <span class="nf">yield </span><span class="p">(</span><span class="sh">"</span><span class="s">sicaklik_ihlali</span><span class="sh">"</span><span class="p">,</span> <span class="n">taraf</span><span class="p">,</span> <span class="n">zaman</span><span class="p">,</span> <span class="n">sicaklik</span><span class="p">)</span>
                <span class="n">bildirildi</span> <span class="o">=</span> <span class="bp">True</span>
</code></pre></div></div>

<p>Burada <code class="language-plaintext highlighter-rouge">okumalar</code>, saat dilimi bilgili zaman nesneleri ve sıcaklık değerlerinden oluşur. Güvenli aralığa dönüş veya sapma yönünün değişmesi sayacı yeniler. Üretimde alarmın kapanması ayrıca histerezisle yönetilebilir: Açılma ve kapanma eşiklerini ayırmak, sınır çevresindeki dalgalanmaların bildirim fırtınasına dönüşmesini önler.</p>

<h2 id="gerçek-zamanlı-demek-her-zaman-çevrimiçi-demek-değildir">Gerçek zamanlı demek, her zaman çevrimiçi demek değildir</h2>

<p>Tünelde bağlantı kesilebilir. Cihaz bu yüzden kayıtları yerelde saklamalı, bağlantı gelince ölçüm zamanlarıyla göndermelidir. Sunucu, mesajın geliş zamanı ile ölçüm zamanını ayırmalı; yinelenen kayıtları benzersiz kimliklerle elemelidir. Ayrıca sessizlik güvenli sıcaklık anlamına gelmez: Canlı sistem, yeni mesaj gelmese bile çalışan ayrı bir zamanlayıcıyla iletişim kaybını yakalamalıdır.</p>

<p>Son olarak TLS, cihaz kimlik doğrulaması, pil takibi ve denetlenebilir alarm geçmişi ekleyin. Alarm, ürünün otomatik olarak kullanılabilir veya kullanılamaz olduğuna karar vermez; kalite ekibinin incelemesini başlatır. Başarı, renkli grafiklerden çok, doğru kişiye zamanında ulaşan güvenilir uyarıdır. Dijital nöbetçi bağırmak için değil, doğru anda konuşmak için vardır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="iot" /><category term="soğuk zincir" /><category term="sensörler" /><category term="python" /><category term="gıda güvenliği" /><category term="gerçek zamanlı izleme" /><summary type="html"><![CDATA[Bir kamyon dolusu yoğurt veya sıcaklığa hassas ilaç düşünün: Yolculuk sorunsuz görünürken açık kalan bir kapı bütün hikâyeyi değiştirebilir. Soğuk zincir takibi, ürünün yalnızca teslimatta değil, yolculuk boyunca uygun koşullarda kaldığını izler. IoT sensörleri burada dijital nöbetçi gibi çalışır: Ölçer, haber verir ve sorun büyümeden müdahale fırsatı sunar.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/soguk-zincirin-dijital-87.png" /><media:content medium="image" url="https://program.sonsuz.us/img/soguk-zincirin-dijital-87.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Talep Tahminiyle Stok Yönetimi: Depodaki Kristal Küreyi İstatistikle Değiştirin</title><link href="https://program.sonsuz.us/posts/talep-tahminiyle-stok-yonetimi-depodaki-kristal-kureyi-istatistikle-degistirin/" rel="alternate" type="text/html" title="Talep Tahminiyle Stok Yönetimi: Depodaki Kristal Küreyi İstatistikle Değiştirin" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/talep-tahminiyle-stok-yonetimi-depodaki-kristal-kureyi-istatistikle-degistirin</id><content type="html" xml:base="https://program.sonsuz.us/posts/talep-tahminiyle-stok-yonetimi-depodaki-kristal-kureyi-istatistikle-degistirin/"><![CDATA[<p>Bir e-ticaret mağazasında en sevilen ürünün tükenmesi müşteriyi, satılmayan kolilerin depoyu doldurması ise muhasebeciyi üzer. Talep tahmini, bu iki mutsuzluğu dengelemeye çalışır. Amaç geleceği kusursuz bilmek değil; geçmiş satışlardan makul bir beklenti üretmek, belirsizliği ölçmek ve bunu uygulanabilir bir sipariş kararına dönüştürmektir.</p>

<p>``</p>

<h2 id="satış-talep-ve-belirsizlik-aynı-şey-değildir">Satış, talep ve belirsizlik aynı şey değildir</h2>

<p>İlk kritik ayrım şudur: Satış verisi her zaman gerçek talebi göstermez. Ürün stokta yokken kaydedilen sıfır satış, müşterilerin ürünü istemediği anlamına gelmez. Bu yüzden stok tükenmeleri, iadeler, kampanyalar ve eksik kayıtlar ayrıca işaretlenmelidir.</p>

<p>Basit bir modelde günlük talep, beklenen seviye ile rastlantısal sapmanın toplamıdır:</p>

\[D_t = μ_t + ε_t\]

<p>Burada $μ_t$ beklenen talebi, $ε_t$ ise modelin açıklayamadığı değişimi temsil eder. Trend, haftalık ritim ve fiyat değişiklikleri beklentiyi etkileyebilir. Rastlantısal bölümse güvenlik stoğunun neden gerekli olduğunu anlatır: Ortalama, tek başına şemsiye değildir!</p>

<h2 id="hangi-tahmin-yöntemiyle-başlamalı">Hangi tahmin yöntemiyle başlamalı?</h2>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Temel mantık</th>
      <th>Uygun durum</th>
      <th>Zayıf noktası</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Hareketli ortalama</td>
      <td>Son dönemlerin ortalaması</td>
      <td>Görece durağan talep</td>
      <td>Ani değişimleri geç izler</td>
    </tr>
    <tr>
      <td>Üstel düzeltme</td>
      <td>Yeni verilere daha fazla ağırlık</td>
      <td>Seviye değişimleri</td>
      <td>Mevsimsellik ayrıca modellenmelidir</td>
    </tr>
    <tr>
      <td>Mevsimsel model</td>
      <td>Tekrarlayan dönemleri öğrenir</td>
      <td>Haftalık veya yıllık döngüler</td>
      <td>Yeterli geçmiş gerekir</td>
    </tr>
    <tr>
      <td>Regresyon</td>
      <td>Talebi açıklayıcı değişkenlerle ilişkilendirir</td>
      <td>Fiyat ve kampanya etkileri</td>
      <td>Gelecek girdiler de bilinmelidir</td>
    </tr>
  </tbody>
</table>

<p>Başlangıçta karmaşık model yerine güçlü bir referans model kurun. Örneğin son 28 günün ortalaması, dört haftalık günlük örüntüyü kısmen dengeler. Ancak cumartesi satışları sistematik olarak yüksekse, tek ortalama günlük farklılıkları yeterince temsil etmez.</p>

<h2 id="tahminden-sipariş-miktarına-geçiş">Tahminden sipariş miktarına geçiş</h2>

<p>Stoğu haftada bir gözden geçirdiğinizi düşünün. Tedarik süresi $L$, gözden geçirme aralığı $R$ ise korunması gereken dönem $H=L+R$ gündür. Çünkü yeni sipariş fırsatına kadar geçen süre de hesaba katılmalıdır.</p>

<p>Günlük ortalama talep $μ$, günlük tahmin hatasının standart sapması $σ_e$ olsun. Hataların yaklaşık bağımsız, sıfır ortalamalı ve durağan olduğu basitleştirmesiyle hedef stok seviyesi:</p>

\[S = Hμ + z_α σ_e \sqrt{H}\]

<p>İlk terim beklenen tüketimdir; ikinci terim güvenlik stoğudur. $z_α$, seçilen çevrim hizmet düzeyinin normal dağılımdaki karşılığıdır. Örneğin yüzde 95 için yaklaşık 1,645 kullanılır. Bu düzey, çevrim boyunca stok tükenmemesi olasılığıdır; taleplerin yüzde 95’inin karşılanacağı anlamına gelmez.</p>

<p>Stok pozisyonu, eldeki stok artı yoldaki siparişler eksi karşılanmamış yükümlülüklerdir. Sipariş miktarı ise:</p>

\[Q = \max(0, \lceil S-IP \rceil)\]

<h2 id="python-ile-küçük-bir-model">Python ile küçük bir model</h2>

<p>Aşağıdaki kod, <code class="language-plaintext highlighter-rouge">tarih</code> ve <code class="language-plaintext highlighter-rouge">adet</code> sütunlu günlük satış dosyasından geçmişe bakan tahminler üretir. Ardından hata ölçeğini kullanarak periyodik gözden geçirme için sipariş önerir.</p>

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

<span class="n">veri</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="nf">read_csv</span><span class="p">(</span><span class="sh">'</span><span class="s">satis.csv</span><span class="sh">'</span><span class="p">,</span> <span class="n">parse_dates</span><span class="o">=</span><span class="p">[</span><span class="sh">'</span><span class="s">tarih</span><span class="sh">'</span><span class="p">])</span>
<span class="n">satis</span> <span class="o">=</span> <span class="p">(</span>
    <span class="n">veri</span><span class="p">.</span><span class="nf">groupby</span><span class="p">(</span><span class="sh">'</span><span class="s">tarih</span><span class="sh">'</span><span class="p">)[</span><span class="sh">'</span><span class="s">adet</span><span class="sh">'</span><span class="p">].</span><span class="nf">sum</span><span class="p">()</span>
    <span class="p">.</span><span class="nf">sort_index</span><span class="p">().</span><span class="nf">asfreq</span><span class="p">(</span><span class="sh">'</span><span class="s">D</span><span class="sh">'</span><span class="p">)</span>
<span class="p">)</span>

<span class="k">if</span> <span class="n">satis</span><span class="p">.</span><span class="nf">isna</span><span class="p">().</span><span class="nf">any</span><span class="p">()</span> <span class="ow">or</span> <span class="nf">len</span><span class="p">(</span><span class="n">satis</span><span class="p">)</span> <span class="o">&lt;</span> <span class="mi">84</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">Eksiksiz en az 84 günlük veri gerekir.</span><span class="sh">'</span><span class="p">)</span>

<span class="c1"># Her günün tahmini yalnızca önceki günlerden oluşur.
</span><span class="n">tahmin</span> <span class="o">=</span> <span class="n">satis</span><span class="p">.</span><span class="nf">rolling</span><span class="p">(</span><span class="mi">28</span><span class="p">).</span><span class="nf">mean</span><span class="p">().</span><span class="nf">shift</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="n">hata</span> <span class="o">=</span> <span class="n">satis</span> <span class="o">-</span> <span class="n">tahmin</span>

<span class="c1"># Son 28 gün, yürüyen tek-adımlı değerlendirme dönemidir.
</span><span class="n">mae</span> <span class="o">=</span> <span class="n">hata</span><span class="p">.</span><span class="n">iloc</span><span class="p">[</span><span class="o">-</span><span class="mi">28</span><span class="p">:].</span><span class="nf">abs</span><span class="p">().</span><span class="nf">mean</span><span class="p">()</span>
<span class="n">sigma</span> <span class="o">=</span> <span class="n">hata</span><span class="p">.</span><span class="n">iloc</span><span class="p">[:</span><span class="o">-</span><span class="mi">28</span><span class="p">].</span><span class="nf">dropna</span><span class="p">().</span><span class="nf">std</span><span class="p">(</span><span class="n">ddof</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="n">mu</span> <span class="o">=</span> <span class="n">satis</span><span class="p">.</span><span class="n">iloc</span><span class="p">[</span><span class="o">-</span><span class="mi">28</span><span class="p">:].</span><span class="nf">mean</span><span class="p">()</span>

<span class="n">L</span><span class="p">,</span> <span class="n">R</span> <span class="o">=</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">7</span>
<span class="n">H</span> <span class="o">=</span> <span class="n">L</span> <span class="o">+</span> <span class="n">R</span>
<span class="n">z</span> <span class="o">=</span> <span class="nc">NormalDist</span><span class="p">().</span><span class="nf">inv_cdf</span><span class="p">(</span><span class="mf">0.95</span><span class="p">)</span>
<span class="n">hedef</span> <span class="o">=</span> <span class="n">H</span> <span class="o">*</span> <span class="n">mu</span> <span class="o">+</span> <span class="n">z</span> <span class="o">*</span> <span class="n">sigma</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="n">H</span><span class="p">)</span>

<span class="n">eldeki</span><span class="p">,</span> <span class="n">yoldaki</span><span class="p">,</span> <span class="n">bekleyen</span> <span class="o">=</span> <span class="mi">120</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">10</span>
<span class="n">pozisyon</span> <span class="o">=</span> <span class="n">eldeki</span> <span class="o">+</span> <span class="n">yoldaki</span> <span class="o">-</span> <span class="n">bekleyen</span>
<span class="n">siparis</span> <span class="o">=</span> <span class="nf">max</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">math</span><span class="p">.</span><span class="nf">ceil</span><span class="p">(</span><span class="n">hedef</span> <span class="o">-</span> <span class="n">pozisyon</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">MAE: </span><span class="si">{</span><span class="n">mae</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">, Sipariş: </span><span class="si">{</span><span class="n">siparis</span><span class="si">}</span><span class="sh">'</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">shift(1)</code>, tahmin edilen günün satışının kendi tahminine sızmasını önler. Son dönem değerlendirmesinde her yeni gerçek satış, sonraki tahmine katılır. Hata standart sapması önceki dönemden hesaplanırken güncel talep seviyesi son 28 günden alınır.</p>

<p>Örneğin $μ=20$, $σ_e=6$ ve $H=11$ için hedef yaklaşık 253 birimdir. Stok pozisyonu 150 olduğunda öneri 103 birim olur. Tedarikçinin koli büyüklüğü varsa sonuç ayrıca koli katına yuvarlanır.</p>

<h2 id="modeli-depoya-bırakmadan-önce">Modeli depoya bırakmadan önce</h2>

<p>MAE, ortalama mutlak hatayı gösterir; fakat sürekli düşük tahmin yapan bir modeli tek başına teşhis etmez. Ortalama hatayı da izleyin ve test dönemlerini zaman sırasıyla ilerletin. Veriyi rastgele karıştırmak, geleceğin geçmişe sızmasına neden olabilir.</p>

<p>Ayrıca $\sqrt{H}$ yaklaşımı evrensel değildir. Çok-adımlı hatalar ilişkiliyse, tedarik süresi değişkense veya talep seyrekse dönem toplamlarını doğrudan modellemek ya da simülasyon yapmak daha uygundur. Son olarak geçmiş üzerinde stok hareketlerini canlandırıp stok tükenmesini, elde tutma maliyetini ve hizmet düzeyini birlikte ölçün. İyi tahmin, depoda işe yarayan tahmindir.</p>

<p><img src="/img/talep-tahminiyle-stok-39.svg" alt="talep-tahminiyle-stok-39" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="talep tahmini" /><category term="stok yönetimi" /><category term="istatistik" /><category term="python" /><category term="zaman serileri" /><category term="veri analizi" /><summary type="html"><![CDATA[Bir e-ticaret mağazasında en sevilen ürünün tükenmesi müşteriyi, satılmayan kolilerin depoyu doldurması ise muhasebeciyi üzer. Talep tahmini, bu iki mutsuzluğu dengelemeye çalışır. Amaç geleceği kusursuz bilmek değil; geçmiş satışlardan makul bir beklenti üretmek, belirsizliği ölçmek ve bunu uygulanabilir bir sipariş kararına dönüştürmektir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/talep-tahminiyle-stok-39.png" /><media:content medium="image" url="https://program.sonsuz.us/img/talep-tahminiyle-stok-39.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Tedarik Zincirinin Darboğazını Bulmak: Ağ Akışıyla Kapasite Planlaması</title><link href="https://program.sonsuz.us/posts/tedarik-zincirinin-darbogazini-bulmak-ag-akisiyla-kapasite-planlamasi/" rel="alternate" type="text/html" title="Tedarik Zincirinin Darboğazını Bulmak: Ağ Akışıyla Kapasite Planlaması" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/tedarik-zincirinin-darbogazini-bulmak-ag-akisiyla-kapasite-planlamasi</id><content type="html" xml:base="https://program.sonsuz.us/posts/tedarik-zincirinin-darbogazini-bulmak-ag-akisiyla-kapasite-planlamasi/"><![CDATA[<p>Fabrikalarınız üretmeye hazır, depolarınız açık, kamyonlarınız çalışıyor… Peki müşterilere gerçekten ne kadar ürün ulaştırabilirsiniz? Üretim kapasitelerini toplamak tek başına yeterli değildir: Aradaki bir depo veya taşıma hattı bütün ağı yavaşlatabilir. Ağ akış teorisi, bu lojistik trafik sıkışıklığını matematiksel olarak görünür kılar ve kapasite yatırımlarını daha bilinçli planlamanızı sağlar.</p>

<p>``</p>

<h2 id="tedarik-ağını-grafa-dönüştürmek">Tedarik ağını grafa dönüştürmek</h2>

<p>Bir tedarik ağını yönlü graf olarak modelleyelim. <strong>Düğümler</strong> üreticileri, depoları ve teslimat noktalarını; <strong>kenarlar</strong> ürünün ilerleyebileceği bağlantıları temsil eder. Her kenarın kapasitesi, belirli bir zaman diliminde taşıyabileceği üst sınırdır.</p>

<p>Örneğimizde bütün kapasiteler ton/gün cinsindendir. İki üreticiyi, iki depoyu ve toplam teslimatı temsil eden bir hedefi kullanacağız. Yapay kaynak düğümü <code class="language-plaintext highlighter-rouge">K</code>, üretim kapasitesini ağa aktarır; hedef <code class="language-plaintext highlighter-rouge">M</code> ise teslim edilen miktarı toplar. Böylece farklı tesisleri tek bir akış hesabında birleştiririz.</p>

<table>
  <thead>
    <tr>
      <th>Bağlantı</th>
      <th style="text-align: right">Kapasite</th>
      <th>Anlamı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>K → U1</td>
      <td style="text-align: right">70</td>
      <td>Birinci üreticinin kapasitesi</td>
    </tr>
    <tr>
      <td>K → U2</td>
      <td style="text-align: right">50</td>
      <td>İkinci üreticinin kapasitesi</td>
    </tr>
    <tr>
      <td>U1 → D1</td>
      <td style="text-align: right">40</td>
      <td>Taşıma hattı</td>
    </tr>
    <tr>
      <td>U1 → D2</td>
      <td style="text-align: right">30</td>
      <td>Taşıma hattı</td>
    </tr>
    <tr>
      <td>U2 → D1</td>
      <td style="text-align: right">20</td>
      <td>Taşıma hattı</td>
    </tr>
    <tr>
      <td>U2 → D2</td>
      <td style="text-align: right">30</td>
      <td>Taşıma hattı</td>
    </tr>
    <tr>
      <td>D1 → M</td>
      <td style="text-align: right">50</td>
      <td>Birinci deponun sevkiyat kapasitesi</td>
    </tr>
    <tr>
      <td>D2 → M</td>
      <td style="text-align: right">40</td>
      <td>İkinci deponun sevkiyat kapasitesi</td>
    </tr>
  </tbody>
</table>

<h2 id="akışın-iki-temel-kuralı">Akışın iki temel kuralı</h2>

<p>Bir kenarın kapasitesi $c(u,v)$, üzerindeki akış ise $f(u,v)$ olsun. İlk kural, kapasiteyi aşmamaktır:</p>

\[0 \le f(u,v) \le c(u,v)\]

<p>İkinci kural, ara düğümlerde <strong>akış korunumu</strong>dur. Kaynak ve hedef dışındaki her düğüme giren toplam miktar, çıkan toplam miktara eşittir:</p>

\[\sum_u f(u,v)=\sum_w f(v,w)\]

<p>Bu modelde ürün kaybolmaz, üretilmez veya dönem sonunda depoda birikmez. Amaç, kaynaktan çıkan toplam akışı, yani $\vert f\vert $ değerini en büyük yapmaktır.</p>

<p>Üretim toplamı $70+50=120$ olsa da depo çıkışları yalnızca $50+40=90$ taşır. Dolayısıyla 120 ton üretim kapasitesi, 120 ton teslimat anlamına gelmez. Maksimum akış burada <strong>90 ton/gün</strong>dür; örneğin U1 üzerinden D1’e 40, D2’ye 30; U2 üzerinden ise her depoya 10 ton gönderilebilir.</p>

<h2 id="algoritma-darboğazı-nasıl-bulur">Algoritma darboğazı nasıl bulur?</h2>

<p>Edmonds–Karp algoritması, kaynak ile hedef arasında <strong>artık kapasitesi</strong> bulunan yolları genişlik öncelikli aramayla bulur. Her turda, yolun en küçük artık kapasitesi kadar akış eklenir. Artık ağdaki ters kenarlar, önceki tahsisleri geri alıp farklı rotalara yönlendirmeyi sağlar. Bu, kamyonları fiziksel olarak geri çağırmak değil, planı yeniden düzenlemektir!</p>

<table>
  <thead>
    <tr>
      <th>Algoritma</th>
      <th>Yol seçimi</th>
      <th>Genel zaman karmaşıklığı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Edmonds–Karp</td>
      <td>BFS ile en az kenarlı yol</td>
      <td>$O(VE^2)$</td>
    </tr>
    <tr>
      <td>Dinic</td>
      <td>Seviye grafında bloklayıcı akış</td>
      <td>$O(V^2E)$</td>
    </tr>
  </tbody>
</table>

<p>Burada $V$ düğüm, $E$ kenar sayısıdır. Büyük ağlarda algoritma seçimi, hesaplama süresini belirgin biçimde etkileyebilir.</p>

<p><strong>Maksimum akış–minimum kesit teoremi</strong>, en büyük akışın en küçük kesitin kapasitesine eşit olduğunu söyler. Kesit, kaynağı hedeften ayıran bir düğüm bölünmesidir. Örneğimizde iki depo çıkışını kesmek, 90 kapasiteli bir minimum kesit oluşturur.</p>

<h2 id="python-ile-hesaplayalım">Python ile hesaplayalım</h2>

<p>Önce <code class="language-plaintext highlighter-rouge">pip install networkx</code> komutuyla kütüphaneyi kurun. Aşağıdaki kod ağı oluşturur, Edmonds–Karp ile maksimum akışı hesaplar ve minimum kesitle sonucu doğrular. <code class="language-plaintext highlighter-rouge">flow</code> sözlüğü, her bağlantıdaki planlanan miktarı içerir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">networkx</span> <span class="k">as</span> <span class="n">nx</span>
<span class="kn">from</span> <span class="n">networkx.algorithms.flow</span> <span class="kn">import</span> <span class="n">edmonds_karp</span>

<span class="n">edges</span> <span class="o">=</span> <span class="p">[</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">K</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">U1</span><span class="sh">"</span><span class="p">,</span> <span class="mi">70</span><span class="p">),</span> <span class="p">(</span><span class="sh">"</span><span class="s">K</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">U2</span><span class="sh">"</span><span class="p">,</span> <span class="mi">50</span><span class="p">),</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">U1</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">D1</span><span class="sh">"</span><span class="p">,</span> <span class="mi">40</span><span class="p">),</span> <span class="p">(</span><span class="sh">"</span><span class="s">U1</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">D2</span><span class="sh">"</span><span class="p">,</span> <span class="mi">30</span><span class="p">),</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">U2</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">D1</span><span class="sh">"</span><span class="p">,</span> <span class="mi">20</span><span class="p">),</span> <span class="p">(</span><span class="sh">"</span><span class="s">U2</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">D2</span><span class="sh">"</span><span class="p">,</span> <span class="mi">30</span><span class="p">),</span>
    <span class="p">(</span><span class="sh">"</span><span class="s">D1</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">,</span> <span class="mi">50</span><span class="p">),</span> <span class="p">(</span><span class="sh">"</span><span class="s">D2</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">,</span> <span class="mi">40</span><span class="p">),</span>
<span class="p">]</span>
<span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="p">.</span><span class="nc">DiGraph</span><span class="p">()</span>
<span class="k">for</span> <span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">capacity</span> <span class="ow">in</span> <span class="n">edges</span><span class="p">:</span>
    <span class="n">G</span><span class="p">.</span><span class="nf">add_edge</span><span class="p">(</span><span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">capacity</span><span class="o">=</span><span class="n">capacity</span><span class="p">)</span>

<span class="n">value</span><span class="p">,</span> <span class="n">flow</span> <span class="o">=</span> <span class="n">nx</span><span class="p">.</span><span class="nf">maximum_flow</span><span class="p">(</span>
    <span class="n">G</span><span class="p">,</span> <span class="sh">"</span><span class="s">K</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">,</span> <span class="n">flow_func</span><span class="o">=</span><span class="n">edmonds_karp</span>
<span class="p">)</span>
<span class="n">cut_value</span><span class="p">,</span> <span class="n">partition</span> <span class="o">=</span> <span class="n">nx</span><span class="p">.</span><span class="nf">minimum_cut</span><span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="sh">"</span><span class="s">K</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">)</span>
<span class="k">assert</span> <span class="n">value</span> <span class="o">==</span> <span class="n">cut_value</span>
<span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">Maksimum akış:</span><span class="sh">"</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>  <span class="c1"># 90
</span>
<span class="n">H</span> <span class="o">=</span> <span class="n">G</span><span class="p">.</span><span class="nf">copy</span><span class="p">()</span>
<span class="n">H</span><span class="p">[</span><span class="sh">"</span><span class="s">D1</span><span class="sh">"</span><span class="p">][</span><span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">][</span><span class="sh">"</span><span class="s">capacity</span><span class="sh">"</span><span class="p">]</span> <span class="o">=</span> <span class="mi">60</span>
<span class="n">H</span><span class="p">[</span><span class="sh">"</span><span class="s">D2</span><span class="sh">"</span><span class="p">][</span><span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">][</span><span class="sh">"</span><span class="s">capacity</span><span class="sh">"</span><span class="p">]</span> <span class="o">=</span> <span class="mi">50</span>
<span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">Yeni kapasite:</span><span class="sh">"</span><span class="p">,</span> <span class="n">nx</span><span class="p">.</span><span class="nf">maximum_flow_value</span><span class="p">(</span><span class="n">H</span><span class="p">,</span> <span class="sh">"</span><span class="s">K</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">M</span><span class="sh">"</span><span class="p">))</span>
<span class="c1"># 110
</span></code></pre></div></div>

<h2 id="sonucu-yatırım-kararına-çevirmek">Sonucu yatırım kararına çevirmek</h2>

<p>Günlük talep 110 tonsa başlangıç planında 20 tonluk açık vardır. Kodun ikinci senaryosunda depo çıkışları artırıldığında toplam kapasite 110’a ulaşır. Sadece üretimi artırmak ise mevcut 90 tonluk kesiti değiştirmediğinden teslimatı yükseltmez. Darboğaz başka yerdeyken fabrikaya yatırım yapmak, geniş bir musluğa dar bir hortum bağlamaya benzer.</p>

<p>Yine de minimum kesit, otomatik olarak en ucuz yatırım önerisi değildir. Kapasite artışlarının maliyetlerini ayrıca değerlendirmek gerekir. Birden fazla minimum kesit varsa yalnızca birini genişletmek de yeterli olmayabilir.</p>

<p>Son olarak bu model, tek ve homojen bir ürün akışını varsayar. Teslimat maliyetleri için minimum maliyetli akış; dönemler arası stok için zaman genişletilmiş ağlar düşünülebilir. Farklı ürünler ortak kapasiteyi paylaşıyorsa daha kapsamlı optimizasyon gerekir. Maksimum akışın cevabı nettir: <strong>Mevcut ağdan en fazla ne geçebilir?</strong></p>

<p><img src="/img/tedarik-zincirinin-darbogazini-59.svg" alt="tedarik-zincirinin-darbogazini-59" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="ağ akışı" /><category term="graf algoritmaları" /><category term="tedarik zinciri" /><category term="kapasite planlaması" /><category term="python" /><category term="optimizasyon" /><summary type="html"><![CDATA[Fabrikalarınız üretmeye hazır, depolarınız açık, kamyonlarınız çalışıyor… Peki müşterilere gerçekten ne kadar ürün ulaştırabilirsiniz? Üretim kapasitelerini toplamak tek başına yeterli değildir: Aradaki bir depo veya taşıma hattı bütün ağı yavaşlatabilir. Ağ akış teorisi, bu lojistik trafik sıkışıklığını matematiksel olarak görünür kılar ve kapasite yatırımlarını daha bilinçli planlamanızı sağlar.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/tedarik-zincirinin-darbogazini-59.png" /><media:content medium="image" url="https://program.sonsuz.us/img/tedarik-zincirinin-darbogazini-59.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">TOTP’nin Perde Arkası: İki Faktörlü Kimlik Doğrulamanın Teknik Temelleri</title><link href="https://program.sonsuz.us/posts/totpnin-perde-arkasi-iki-faktorlu-kimlik-dogrulamanin-teknik-temelleri/" rel="alternate" type="text/html" title="TOTP’nin Perde Arkası: İki Faktörlü Kimlik Doğrulamanın Teknik Temelleri" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/totpnin-perde-arkasi-iki-faktorlu-kimlik-dogrulamanin-teknik-temelleri</id><content type="html" xml:base="https://program.sonsuz.us/posts/totpnin-perde-arkasi-iki-faktorlu-kimlik-dogrulamanin-teknik-temelleri/"><![CDATA[<p>Telefonunuzdaki altı haneli kodun her otuz saniyede değişmesi küçük bir sihir gösterisi gibi görünebilir. Oysa perde arkasında saat, ortak bir sır ve kriptografik bir hesaplama vardır. Gelin bu mekanizmayı açıp hem üretimi hem doğrulamayı inceleyelim.</p>

<p><img src="/img/totpnin-perde-arkasi-84.svg" alt="totpnin-perde-arkasi-84" /></p>

<p>``</p>

<h2 id="i̇ki-faktör-gerçekten-ne-demek">İki faktör gerçekten ne demek?</h2>

<p>Kimlik doğrulama faktörleri; bildiğiniz şey, sahip olduğunuz şey ve biyometrik özelliğiniz olarak sınıflandırılır. Parola ilk gruptadır; TOTP sırrını taşıyan doğrulayıcı uygulama ikinci grubu temsil eder. Dolayısıyla iki farklı parola kullanmak, iki faktörlü doğrulama değildir.</p>

<p>TOTP, RFC 6238 ile tanımlanır ve sayaç tabanlı HOTP algoritmasının zamanla çalışan türevidir.</p>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Değişen girdi</th>
      <th>Temel özellik</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>HOTP</td>
      <td>Artan sayaç</td>
      <td>Sayaçların eşleşmesi gerekir</td>
    </tr>
    <tr>
      <td>TOTP</td>
      <td>Zaman dilimi</td>
      <td>Saatlerin yakın olması gerekir</td>
    </tr>
    <tr>
      <td>WebAuthn</td>
      <td>Sunucunun meydan okuması</td>
      <td>Alan adına bağlanarak oltalamaya direnç sağlar</td>
    </tr>
  </tbody>
</table>

<h2 id="saatten-sayaca-zamanın-dilimlenmesi">Saatten sayaca: zamanın dilimlenmesi</h2>

<p>Telefon ile sunucu, kullanıcıya özel aynı gizli anahtarı paylaşır. Anahtar genellikle kurulum sırasında QR koduyla aktarılır; uygulama kod üretirken sunucuyla konuşmak zorunda değildir.</p>

<p>Unix zamanı $t$, başlangıç zamanı $T_0$ ve adım uzunluğu $X$ kullanılarak sayaç hesaplanır:</p>

\[T = \lfloor (t - T_0) / X \rfloor\]

<p>Yaygın seçimler $T_0 = 0$ ve $X = 30$ saniyedir. Aynı dilimdeki zamanlar aynı sayacı verir. Saat diliminiz değil, cihazınızın gerçek zamanının doğruluğu önemlidir.</p>

<h2 id="hmac-ortak-sırrın-mutfağı">HMAC: ortak sırrın mutfağı</h2>

<p>Sayaç, sekiz baytlık büyük uçlu bir sayı olarak kodlanır. Ardından gizli anahtar $K$ ile HMAC hesaplanır. Yaygın seçenek HMAC-SHA-1 olsa da standart SHA-256 ve SHA-512 kullanımını da tanımlar; istemci ve sunucu aynı seçimi yapmalıdır.</p>

<p>Özetin son baytındaki düşük dört bit, dinamik kesmenin başlangıç konumunu belirler. Buradan alınan dört baytın en yüksek biti temizlenerek 31 bitlik pozitif sayı elde edilir:</p>

\[OTP = B \bmod 10^d\]

<p>Burada $d$, basamak sayısıdır. Sonuç sıfırlarla tamamlanır: <code class="language-plaintext highlighter-rouge">004821</code>, geçerli bir altı haneli koddur.</p>

<h2 id="python-ile-üretim-ve-doğrulama">Python ile üretim ve doğrulama</h2>

<p>Aşağıdaki örnek, standart kütüphaneyle altı haneli TOTP üretir. Doğrulayıcı, eşleşen zaman sayacını döndürür; bu bilgi tekrar kullanımın engellenmesinde işe yarar.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">base64</span>
<span class="kn">import</span> <span class="n">hashlib</span>
<span class="kn">import</span> <span class="n">hmac</span>
<span class="kn">import</span> <span class="n">struct</span>
<span class="kn">import</span> <span class="n">time</span>


<span class="k">def</span> <span class="nf">totp</span><span class="p">(</span><span class="n">secret</span><span class="p">,</span> <span class="n">timestamp</span><span class="p">):</span>
    <span class="n">normalized</span> <span class="o">=</span> <span class="n">secret</span><span class="p">.</span><span class="nf">strip</span><span class="p">().</span><span class="nf">upper</span><span class="p">()</span>
    <span class="n">padding</span> <span class="o">=</span> <span class="sh">"</span><span class="s">=</span><span class="sh">"</span> <span class="o">*</span> <span class="p">((</span><span class="o">-</span><span class="nf">len</span><span class="p">(</span><span class="n">normalized</span><span class="p">))</span> <span class="o">%</span> <span class="mi">8</span><span class="p">)</span>
    <span class="n">key</span> <span class="o">=</span> <span class="n">base64</span><span class="p">.</span><span class="nf">b32decode</span><span class="p">(</span><span class="n">normalized</span> <span class="o">+</span> <span class="n">padding</span><span class="p">)</span>
    <span class="n">counter</span> <span class="o">=</span> <span class="nf">int</span><span class="p">(</span><span class="n">timestamp</span> <span class="o">//</span> <span class="mi">30</span><span class="p">)</span>
    <span class="n">message</span> <span class="o">=</span> <span class="n">struct</span><span class="p">.</span><span class="nf">pack</span><span class="p">(</span><span class="sh">"</span><span class="s">&gt;Q</span><span class="sh">"</span><span class="p">,</span> <span class="n">counter</span><span class="p">)</span>
    <span class="n">digest</span> <span class="o">=</span> <span class="n">hmac</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">message</span><span class="p">,</span> <span class="n">hashlib</span><span class="p">.</span><span class="n">sha1</span><span class="p">).</span><span class="nf">digest</span><span class="p">()</span>
    <span class="n">offset</span> <span class="o">=</span> <span class="n">digest</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">&amp;</span> <span class="mh">0x0F</span>
    <span class="n">value</span> <span class="o">=</span> <span class="nb">int</span><span class="p">.</span><span class="nf">from_bytes</span><span class="p">(</span><span class="n">digest</span><span class="p">[</span><span class="n">offset</span><span class="p">:</span><span class="n">offset</span> <span class="o">+</span> <span class="mi">4</span><span class="p">],</span> <span class="sh">"</span><span class="s">big</span><span class="sh">"</span><span class="p">)</span>
    <span class="n">value</span> <span class="o">&amp;=</span> <span class="mh">0x7FFFFFFF</span>
    <span class="k">return</span> <span class="sa">f</span><span class="sh">"</span><span class="si">{</span><span class="n">value</span> <span class="o">%</span> <span class="mi">1_000_000</span><span class="si">:</span><span class="mi">06</span><span class="n">d</span><span class="si">}</span><span class="sh">"</span>


<span class="k">def</span> <span class="nf">matching_counter</span><span class="p">(</span><span class="n">secret</span><span class="p">,</span> <span class="n">code</span><span class="p">,</span> <span class="n">now</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="nf">isinstance</span><span class="p">(</span><span class="n">code</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">None</span>
    <span class="k">if</span> <span class="nf">len</span><span class="p">(</span><span class="n">code</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">6</span> <span class="ow">or</span> <span class="ow">not</span> <span class="n">code</span><span class="p">.</span><span class="nf">isascii</span><span class="p">()</span> <span class="ow">or</span> <span class="ow">not</span> <span class="n">code</span><span class="p">.</span><span class="nf">isdigit</span><span class="p">():</span>
        <span class="k">return</span> <span class="bp">None</span>
    <span class="n">now</span> <span class="o">=</span> <span class="n">time</span><span class="p">.</span><span class="nf">time</span><span class="p">()</span> <span class="k">if</span> <span class="n">now</span> <span class="ow">is</span> <span class="bp">None</span> <span class="k">else</span> <span class="n">now</span>
    <span class="n">current</span> <span class="o">=</span> <span class="nf">int</span><span class="p">(</span><span class="n">now</span> <span class="o">//</span> <span class="mi">30</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">delta</span> <span class="ow">in</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">):</span>
        <span class="n">counter</span> <span class="o">=</span> <span class="n">current</span> <span class="o">+</span> <span class="n">delta</span>
        <span class="n">expected</span> <span class="o">=</span> <span class="nf">totp</span><span class="p">(</span><span class="n">secret</span><span class="p">,</span> <span class="n">counter</span> <span class="o">*</span> <span class="mi">30</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">hmac</span><span class="p">.</span><span class="nf">compare_digest</span><span class="p">(</span><span class="n">expected</span><span class="p">,</span> <span class="n">code</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">counter</span>
    <span class="k">return</span> <span class="bp">None</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">struct.pack</code>, sayacı HMAC için doğru bayt biçimine dönüştürür. Bit maskeleri dinamik kesmeyi uygular; <code class="language-plaintext highlighter-rouge">compare_digest</code> ise kod karşılaştırmasındaki zamanlama sızıntısını azaltır. Eşleşme kontrolünde <code class="language-plaintext highlighter-rouge">is not None</code> kullanın.</p>

<p>Doğrulama penceresi önceki, mevcut ve sonraki dilimi kapsar. Bu tolerans saat kaymalarını karşılar; ancak kabul edilebilecek kod sayısını da artırır. Altı hane ve üç dilim için rastgele tek denemenin başarı olasılığı yaklaşık $3/10^6$ olur.</p>

<h2 id="üretimde-eksik-bırakılmaması-gerekenler">Üretimde eksik bırakılmaması gerekenler</h2>

<ul>
  <li><strong>Sır yönetimi:</strong> Her kullanıcı için kriptografik rastgelelik kullanın; örneğin <code class="language-plaintext highlighter-rouge">secrets.token_bytes(20)</code> ile anahtar üretip Base32 kodlayın. Base32 şifreleme değildir. Sunucu sırrı geri okuyabilmelidir; bu yüzden parola gibi yalnızca özetleyemezsiniz. Şifreleyin ve erişimi sınırlandırın.</li>
  <li><strong>Tekrar kullanımı:</strong> Kabul edilen sayacı kullanıcıyla ilişkilendirin. Daha önce tüketilmiş dilimleri reddetme ve yeni sayacı kaydetme işlemini atomik yapın; aksi hâlde eşzamanlı istekler aynı kodu kullanabilir.</li>
  <li><strong>Deneme sınırı:</strong> Hesap bazlı hız sınırlaması, kademeli gecikme ve güvenlik kayıtları uygulayın. Sunucu saatini güvenilir zaman senkronizasyonuyla koruyun.</li>
  <li><strong>Kurulum ve kurtarma:</strong> Faktörü etkinleştirmeden önce bir kod doğrulatın. Yedek kodları tek kullanımlık üretip özetleyerek saklayın. Faktör değişikliğinde yeniden kimlik doğrulaması isteyin; sırları ve QR içeriklerini günlüklemeyin.</li>
</ul>

<p>TOTP, çalınan parolaya karşı güçlü bir ek katmandır; fakat kodlar sahte sitelere aktarılabilir. Oltalama direnci gerekiyorsa WebAuthn tercih edin: güvenliğin son patronu yalnızca altı rakam değildir!</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="güvenlik" /><category term="iki faktörlü doğrulama" /><category term="totp" /><category term="kriptografi" /><category term="python" /><category term="kimlik doğrulama" /><summary type="html"><![CDATA[Telefonunuzdaki altı haneli kodun her otuz saniyede değişmesi küçük bir sihir gösterisi gibi görünebilir. Oysa perde arkasında saat, ortak bir sır ve kriptografik bir hesaplama vardır. Gelin bu mekanizmayı açıp hem üretimi hem doğrulamayı inceleyelim.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/totpnin-perde-arkasi-84.png" /><media:content medium="image" url="https://program.sonsuz.us/img/totpnin-perde-arkasi-84.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Uzaydan Gelen Veriyi Bekletmeyin: Uydu Haberleşmesinde Gecikme ve Bant Genişliği Yönetimi</title><link href="https://program.sonsuz.us/posts/uzaydan-gelen-veriyi-bekletmeyin-uydu-haberlesmesinde-gecikme-ve-bant-genisligi-yonetimi/" rel="alternate" type="text/html" title="Uzaydan Gelen Veriyi Bekletmeyin: Uydu Haberleşmesinde Gecikme ve Bant Genişliği Yönetimi" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/uzaydan-gelen-veriyi-bekletmeyin-uydu-haberlesmesinde-gecikme-ve-bant-genisligi-yonetimi</id><content type="html" xml:base="https://program.sonsuz.us/posts/uzaydan-gelen-veriyi-bekletmeyin-uydu-haberlesmesinde-gecikme-ve-bant-genisligi-yonetimi/"><![CDATA[<p>Okyanustaki bir araştırma gemisi, çöldeki otonom araç veya dağların arasındaki keşif robotu düşünün. Hepsi komuta merkezine veri göndermek istiyor; fakat aralarında kilometrelerce boşluk, hareketli bağlantılar ve sınırlı kapasite var. Uydu haberleşmesinde başarı, yalnızca güçlü bir antenle değil, hangi verinin ne zaman gönderileceğine doğru karar vermekle geliyor.
``</p>

<h2 id="gecikmenin-anatomisi-mesafe-pazarlık-kabul-etmez">Gecikmenin anatomisi: Mesafe pazarlık kabul etmez</h2>

<p>Tek yönlü gecikmeyi kabaca şu şekilde ayırabiliriz:</p>

\[T = d/c + L/R + T_q + T_p\]

<p>Burada $d$ sinyalin izlediği mesafe, $c$ ışık hızı, $L$ paket uzunluğu, $R$ iletim hızı, $T_q$ kuyrukta bekleme ve $T_p$ işleme süresidir. İlk terim fizik kurallarına bağlıdır; diğerlerini ağ tasarımıyla iyileştirebiliriz. Büyük bir görüntü paketi, küçük bir alarmın önünde bekliyorsa sorun yalnızca uzayda değildir!</p>

<p>Jeostatik yörüngedeki bir uydunun yüksekliği yaklaşık 35.786 kilometredir. Araç–uydu–yer istasyonu güzergâhında gidiş-dönüş yayılım gecikmesinin ideal alt sınırı yaklaşık $4h/c = 0.477$ saniyedir. Gerçek rota, işleme ve kuyruklar bu değeri artırır. <strong>RTT</strong>, paketin gidip yanıtının dönmesi için geçen toplam süredir.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>GEO</th>
      <th>LEO</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Yörünge</td>
      <td>Jeostatik, yüksek</td>
      <td>Alçak, hareketli</td>
    </tr>
    <tr>
      <td>Yayılım gecikmesi</td>
      <td>Daha yüksek</td>
      <td>Genellikle daha düşük</td>
    </tr>
    <tr>
      <td>Kapsama</td>
      <td>Geniş ve görece sabit</td>
      <td>Takımyıldızına bağlı</td>
    </tr>
    <tr>
      <td>Yönetim zorluğu</td>
      <td>Uzun RTT</td>
      <td>Uydu geçişleri ve değişken rota</td>
    </tr>
  </tbody>
</table>

<h2 id="bant-genişliği-ile-gerçek-veri-hızı-aynı-değildir">Bant genişliği ile gerçek veri hızı aynı değildir</h2>

<p>Frekans bant genişliği hertz, veri hızı ise bit/saniye cinsinden ölçülür. İdeal kanal kapasitesini Shannon bağıntısı açıklar:</p>

\[C = B \log_2(1 + S/N)\]

<p>$B$ frekans bant genişliği, $S/N$ sinyal-gürültü oranıdır. Ancak protokol başlıkları, hata düzeltme, yeniden iletimler ve hava koşulları kullanılabilir uygulama hızını düşürür. Yağmur zayıflaması gibi etkilerde modem daha dayanıklı bir kodlamaya geçebilir; bağlantı korunurken kapasite azalır.</p>

<p>Bir başka kritik değer <strong>bant genişliği–gecikme çarpımıdır</strong>: $BDP = R \times RTT$. Hızı 2 Mbit/s, RTT değeri 0,6 saniye olan bağlantıda yaklaşık 150 kB veri aynı anda yolda bulunabilir. Aktarım penceresi bunu desteklemelidir; fakat gereksiz büyük kuyruklar gecikmeyi şişirir.</p>

<h2 id="önceliklendirme-alarm-önce-manzara-sonra">Önceliklendirme: Alarm önce, manzara sonra</h2>

<p>Araçtan merkeze gönderilen veriyi sınıflandırın: acil olaylar, düzenli telemetri ve büyük dosyalar. Aşağıdaki Python örneği, öncelik kuyruğunu <strong>token bucket</strong> hız sınırlayıcısıyla birleştirir. Küçük öncelik sayısı daha önemlidir.</p>

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

<span class="k">class</span> <span class="nc">LinkScheduler</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">rate</span><span class="o">=</span><span class="mi">250_000</span><span class="p">,</span> <span class="n">burst</span><span class="o">=</span><span class="mi">64_000</span><span class="p">):</span>
        <span class="n">self</span><span class="p">.</span><span class="n">rate</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">burst</span> <span class="o">=</span> <span class="n">rate</span><span class="p">,</span> <span class="n">burst</span>
        <span class="n">self</span><span class="p">.</span><span class="n">tokens</span> <span class="o">=</span> <span class="nf">float</span><span class="p">(</span><span class="n">burst</span><span class="p">)</span>
        <span class="n">self</span><span class="p">.</span><span class="n">updated</span> <span class="o">=</span> <span class="n">time</span><span class="p">.</span><span class="nf">monotonic</span><span class="p">()</span>
        <span class="n">self</span><span class="p">.</span><span class="n">queue</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="n">self</span><span class="p">.</span><span class="n">sequence</span> <span class="o">=</span> <span class="n">itertools</span><span class="p">.</span><span class="nf">count</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">enqueue</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">priority</span><span class="p">,</span> <span class="n">payload</span><span class="p">):</span>
        <span class="k">if</span> <span class="nf">len</span><span class="p">(</span><span class="n">payload</span><span class="p">)</span> <span class="o">&gt;</span> <span class="n">self</span><span class="p">.</span><span class="n">burst</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">Veriyi küçük parçalara bölün</span><span class="sh">"</span><span class="p">)</span>
        <span class="n">heapq</span><span class="p">.</span><span class="nf">heappush</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">queue</span><span class="p">,</span>
                      <span class="p">(</span><span class="n">priority</span><span class="p">,</span> <span class="nf">next</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">sequence</span><span class="p">),</span> <span class="n">payload</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">next_packet</span><span class="p">(</span><span class="n">self</span><span class="p">):</span>
        <span class="n">now</span> <span class="o">=</span> <span class="n">time</span><span class="p">.</span><span class="nf">monotonic</span><span class="p">()</span>
        <span class="n">self</span><span class="p">.</span><span class="n">tokens</span> <span class="o">=</span> <span class="nf">min</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">burst</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">tokens</span> <span class="o">+</span>
                          <span class="p">(</span><span class="n">now</span> <span class="o">-</span> <span class="n">self</span><span class="p">.</span><span class="n">updated</span><span class="p">)</span> <span class="o">*</span> <span class="n">self</span><span class="p">.</span><span class="n">rate</span><span class="p">)</span>
        <span class="n">self</span><span class="p">.</span><span class="n">updated</span> <span class="o">=</span> <span class="n">now</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="n">self</span><span class="p">.</span><span class="n">queue</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">None</span>
        <span class="n">payload</span> <span class="o">=</span> <span class="n">self</span><span class="p">.</span><span class="n">queue</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">2</span><span class="p">]</span>
        <span class="k">if</span> <span class="nf">len</span><span class="p">(</span><span class="n">payload</span><span class="p">)</span> <span class="o">&gt;</span> <span class="n">self</span><span class="p">.</span><span class="n">tokens</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">None</span>
        <span class="n">self</span><span class="p">.</span><span class="n">tokens</span> <span class="o">-=</span> <span class="nf">len</span><span class="p">(</span><span class="n">payload</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">heapq</span><span class="p">.</span><span class="nf">heappop</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">queue</span><span class="p">)[</span><span class="mi">2</span><span class="p">]</span>
</code></pre></div></div>

<p>Varsayılan hız 250.000 bayt/saniye, yani 2 Mbit/s’dir. Tokenlar gönderim bütçesini temsil eder; sıra numarası eşit öncelikleri geliş sırasına göre düzenler. Çağıran döngü, dönen paketi modeme verir; <code class="language-plaintext highlighter-rouge">None</code> geldiğinde bekler. Bu, öğretici bir iskelettir: üretimde kuyruk sınırı, süre aşımı ve düşük öncelikli trafiğin sürekli beklemesini önleyen ağırlıklı paylaşım eklenmelidir.</p>

<h2 id="her-veri-aynı-güvenilirliği-istemez">Her veri aynı güvenilirliği istemez</h2>

<p>Konum güncellemelerinde bazen en yeni ölçüm, kaybolan eski ölçümden değerlidir. Dosyalarda ise bütünlük gerekir. UDP tek başına teslim garantisi vermez; TCP güvenilir aktarım sağlar, ancak uzun RTT ve kayıplar performansını etkiler. QUIC de sihirli bir gecikme silgisi değildir: tıkanıklık kontrolü ve bağlantı koşulları hâlâ önemlidir.</p>

<ul>
  <li>Telemetriye zaman damgası ve sıra numarası ekleyin.</li>
  <li>Kritik işlemlerde onay, kimlik doğrulama ve tekrarları ayıklama kullanın.</li>
  <li>Kopmalarda veriyi yerelde saklayıp bağlantı dönünce aktarın.</li>
  <li>Süresi geçmiş komutları çalıştırmayın; güvenli davranışı araçta tanımlayın.</li>
</ul>

<h2 id="küçük-bir-kapasite-bütçesi">Küçük bir kapasite bütçesi</h2>

<p>2 Mbit/s bağlantıda 100 aracın her saniye 250 bayt telemetri üretmesi, başlıklar hariç 200 kbit/s tüketir. Acil olaylara 100 kbit/s, görüntülere 1,3 Mbit/s ayırıp 400 kbit/s pay bırakabilirsiniz. Bu pay protokol yükü ve dalgalanmalar içindir; ölçümlerle güncellenmelidir.</p>

<p>Görüntülere ayrılan hızda 1 MB dosyanın ideal aktarımı yaklaşık 6,2 saniyedir. Dosyayı küçük parçalara bölmek, alarmların araya girmesini kolaylaştırır. Fark verilerini göndermek ve yerelde özet çıkarmak da maliyeti azaltır.</p>

<p>Son olarak RTT’yi, paket kaybını, kuyruk yaşını ve gerçekten teslim edilen uygulama verisini izleyin. Hedef, hattı sürekli doldurmak değil; komuta merkezine <strong>doğru veriyi, işe yarayacağı zamanda</strong> ulaştırmaktır.</p>

<p><img src="/img/uzaydan-gelen-veriyi-74.svg" alt="uzaydan-gelen-veriyi-74" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="uydu haberleşmesi" /><category term="gecikme" /><category term="bant genişliği" /><category term="telemetri" /><category term="python" /><category term="ağ yönetimi" /><summary type="html"><![CDATA[Okyanustaki bir araştırma gemisi, çöldeki otonom araç veya dağların arasındaki keşif robotu düşünün. Hepsi komuta merkezine veri göndermek istiyor; fakat aralarında kilometrelerce boşluk, hareketli bağlantılar ve sınırlı kapasite var. Uydu haberleşmesinde başarı, yalnızca güçlü bir antenle değil, hangi verinin ne zaman gönderileceğine doğru karar vermekle geliyor.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/uzaydan-gelen-veriyi-74.png" /><media:content medium="image" url="https://program.sonsuz.us/img/uzaydan-gelen-veriyi-74.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Zafiyet Tarama Araçlarının Çalışma Mantığı: Dijital Dedektifler Nasıl İz Sürer?</title><link href="https://program.sonsuz.us/posts/zafiyet-tarama-araclarinin-calisma-mantigi-dijital-dedektifler-nasil-iz-surer/" rel="alternate" type="text/html" title="Zafiyet Tarama Araçlarının Çalışma Mantığı: Dijital Dedektifler Nasıl İz Sürer?" /><published>2026-11-10T00:00:00+00:00</published><updated>2026-11-10T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/zafiyet-tarama-araclarinin-calisma-mantigi-dijital-dedektifler-nasil-iz-surer</id><content type="html" xml:base="https://program.sonsuz.us/posts/zafiyet-tarama-araclarinin-calisma-mantigi-dijital-dedektifler-nasil-iz-surer/"><![CDATA[<p><img src="/img/zafiyet-tarama-araclarinin-78.svg" alt="zafiyet-tarama-araclarinin-78" /></p>

<p>Bir zafiyet tarayıcısı, sunucunuza bakıp sihirli biçimde “Burada açık var!” diyen bir kristal küre değildir. Daha çok envanter çıkaran, ipuçlarını güvenlik duyurularıyla karşılaştıran ve şüpheli durumları raporlayan dijital bir dedektiftir. Peki bu dedektif hangi izleri takip eder, bulgularına ne kadar güvenebiliriz ve otomasyon nerede durmalıdır?</p>

<p>``</p>

<h2 id="1-önce-sistemi-tanımak-keşif-ve-envanter">1. Önce sistemi tanımak: keşif ve envanter</h2>

<p>Taramanın başlangıcı, hangi varlıkların inceleneceğini belirlemektir. IP adresleri, alan adları, sunucular, konteyner imajları ve kurulu paketler bu kapsamın parçaları olabilir. Tarama yalnızca izin verilen sistemlerde, belirlenmiş zaman aralıkları ve hız sınırlarıyla yürütülmelidir.</p>

<p>Ağ tabanlı araçlar erişilebilir servisleri ve bağlantı noktalarını araştırır. Ardından protokol yanıtları, HTTP başlıkları veya servis banner’ları üzerinden ürün ve sürüm tahmini yapar. Ancak banner, nüfus cüzdanı değildir: gizlenebilir, yanlış yapılandırılabilir veya güncel olmayan bilgiler taşıyabilir.</p>

<h2 id="2-bilinen-açıklarla-eşleştirme">2. Bilinen açıklarla eşleştirme</h2>

<p>Keşfedilen bilgiler, üretici duyuruları ve zafiyet veri kaynaklarıyla karşılaştırılır. <strong>CVE</strong>, bir açıklığın ortak kimliğidir; <strong>CPE</strong> ise ürünleri adlandırmak için kullanılan standartlaştırılmış bir yapıdır. Bunlar aynı şey değildir: biri güvenlik problemini, diğeri ilgili yazılımı tanımlar.</p>

<p>Temel mantık şöyle gösterilebilir:</p>

\[Bulgular = Varlıklar \bowtie_{ürün,\ sürüm,\ koşullar} ZafiyetKuralları\]

<p>Buradaki birleştirme, yalnızca sürüm karşılaştırması değildir. İşletim sistemi, etkin özellikler, paket kaynağı ve yapılandırma koşulları da sonucu değiştirebilir. Tarayıcı eklentileri bu koşulları değerlendiren kontrolleri içerir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Bilgi kaynağı</th>
      <th>Güçlü yanı</th>
      <th>Sınırlaması</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Kimlik bilgisiz tarama</td>
      <td>Dışarıdan görülen yanıtlar</td>
      <td>Saldırı yüzeyini gösterir</td>
      <td>İçerideki paketleri göremeyebilir</td>
    </tr>
    <tr>
      <td>Kimlik bilgili tarama</td>
      <td>Yetkili hesapla yerel inceleme</td>
      <td>Paket ve yama bilgisi daha nettir</td>
      <td>Güvenli hesap yönetimi gerekir</td>
    </tr>
    <tr>
      <td>Pasif gözlem</td>
      <td>Mevcut trafik ve kayıtlar</td>
      <td>Ek sorgu üretmez</td>
      <td>Görülmeyen servisleri kaçırabilir</td>
    </tr>
  </tbody>
</table>

<h2 id="3-küçük-bir-eşleştirme-motoru">3. Küçük bir eşleştirme motoru</h2>

<p>Aşağıdaki Python örneği ağ taraması yapmaz; hazırlanmış envanteri yerel kurallarla karşılaştırıp JSON raporu üretir. <code class="language-plaintext highlighter-rouge">DEMO-001</code> tamamen sentetiktir, gerçek bir CVE değildir. Bağımlılık için <code class="language-plaintext highlighter-rouge">pip install packaging</code> komutu yeterlidir.</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">from</span> <span class="n">packaging.version</span> <span class="kn">import</span> <span class="n">Version</span><span class="p">,</span> <span class="n">InvalidVersion</span>

<span class="n">assets</span> <span class="o">=</span> <span class="p">[</span>
    <span class="p">{</span><span class="sh">"</span><span class="s">host</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">lab-01</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">product</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">ornek-web</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">version</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">2.3.0</span><span class="sh">"</span><span class="p">}</span>
<span class="p">]</span>
<span class="n">rules</span> <span class="o">=</span> <span class="p">[</span>
    <span class="p">{</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">DEMO-001</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">product</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">ornek-web</span><span class="sh">"</span><span class="p">,</span>
     <span class="sh">"</span><span class="s">introduced</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">2.0.0</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">fixed</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">2.4.1</span><span class="sh">"</span><span class="p">}</span>
<span class="p">]</span>
<span class="n">findings</span> <span class="o">=</span> <span class="p">[]</span>

<span class="k">for</span> <span class="n">asset</span> <span class="ow">in</span> <span class="n">assets</span><span class="p">:</span>
    <span class="k">for</span> <span class="n">rule</span> <span class="ow">in</span> <span class="n">rules</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">asset</span><span class="p">[</span><span class="sh">"</span><span class="s">product</span><span class="sh">"</span><span class="p">]</span> <span class="o">!=</span> <span class="n">rule</span><span class="p">[</span><span class="sh">"</span><span class="s">product</span><span class="sh">"</span><span class="p">]:</span>
            <span class="k">continue</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">version</span> <span class="o">=</span> <span class="nc">Version</span><span class="p">(</span><span class="n">asset</span><span class="p">[</span><span class="sh">"</span><span class="s">version</span><span class="sh">"</span><span class="p">])</span>
            <span class="n">affected</span> <span class="o">=</span> <span class="p">(</span>
                <span class="nc">Version</span><span class="p">(</span><span class="n">rule</span><span class="p">[</span><span class="sh">"</span><span class="s">introduced</span><span class="sh">"</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="n">version</span>
                <span class="o">&lt;</span> <span class="nc">Version</span><span class="p">(</span><span class="n">rule</span><span class="p">[</span><span class="sh">"</span><span class="s">fixed</span><span class="sh">"</span><span class="p">])</span>
            <span class="p">)</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">affected</span><span class="p">:</span>
                <span class="k">continue</span>
            <span class="n">status</span> <span class="o">=</span> <span class="sh">"</span><span class="s">potansiyel zafiyet</span><span class="sh">"</span>
        <span class="k">except</span> <span class="n">InvalidVersion</span><span class="p">:</span>
            <span class="n">status</span> <span class="o">=</span> <span class="sh">"</span><span class="s">sürüm doğrulanamadı</span><span class="sh">"</span>
        <span class="n">findings</span><span class="p">.</span><span class="nf">append</span><span class="p">({</span><span class="o">**</span><span class="n">asset</span><span class="p">,</span> <span class="sh">"</span><span class="s">rule</span><span class="sh">"</span><span class="p">:</span> <span class="n">rule</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">],</span> <span class="sh">"</span><span class="s">status</span><span class="sh">"</span><span class="p">:</span> <span class="n">status</span><span class="p">})</span>

<span class="nf">print</span><span class="p">(</span><span class="n">json</span><span class="p">.</span><span class="nf">dumps</span><span class="p">(</span><span class="n">findings</span><span class="p">,</span> <span class="n">ensure_ascii</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">))</span>
</code></pre></div></div>

<p>Kod, ürün adı eşleştiğinde sürümün etkilenen aralıkta bulunup bulunmadığını denetler. Ayrıştırılamayan sürümleri güvenli saymak yerine belirsiz olarak raporlar. Gerçek araçlarda ürün takma adları, farklı sürüm şemaları ve dağıtıcı yamaları için çok daha ayrıntılı kurallar gerekir; <code class="language-plaintext highlighter-rouge">packaging</code> bütün üreticilerin sürüm biçimlerini kapsamaz.</p>

<h2 id="4-bulgu-neden-kesin-kanıt-değildir">4. Bulgu neden kesin kanıt değildir?</h2>

<p>Bazı Linux dağıtımları güvenlik düzeltmesini eski sürüme taşır; buna <strong>backport</strong> denir. Dolayısıyla eski görünen sürüm mutlaka savunmasız değildir. Tersi de mümkündür: sürüm gizlendiği için tarayıcı gerçek bir açığı kaçırabilir.</p>

<p>Yanlış pozitif, gerçekte bulunmayan bir açığın raporlanmasıdır. Yanlış negatif ise mevcut açığın atlanmasıdır. Bu nedenle iyi raporlar kullanılan kontrolü, elde edilen kanıtı ve güven düzeyini gösterir. Kontrollü doğrulama yardımcı olabilir; ancak açıklığı sömürmek taramanın zorunlu adımı değildir ve ayrıca yetkilendirilmelidir.</p>

<h2 id="5-raporlama-ve-önceliklendirme">5. Raporlama ve önceliklendirme</h2>

<p><strong>CVSS</strong>, teknik ciddiyeti ifade eder; tek başına saldırıya uğrama olasılığı değildir. İnternete açık kritik bir servisle izole laboratuvar makinesi aynı operasyonel önceliğe sahip olmayabilir.</p>

<p>Örnek bir öncelik modeli:</p>

\[P = 0.4S + 0.3E + 0.2A + 0.1K\]

<p>Burada tüm değerler $[0,1]$ aralığındadır: $S$ normalize edilmiş ciddiyet, $E$ dış erişilebilirlik, $A$ varlık önemi, $K$ ise bilinen aktif istismar göstergesidir. Bu öğretici formül, standart CVSS hesabı veya ölçülmüş olasılık değildir.</p>

<p>Kullanışlı rapor; varlığı, ilgili CVE’yi veya kuralı, kanıtı, etkilenen bileşeni ve düzeltme önerisini birlikte sunar. Üretici yaması, yapılandırma değişikliği veya geçici erişim kısıtlaması uygulanabilir. Ardından yeniden tarama yapılarak bulgunun kapandığı doğrulanır.</p>

<p>Sonuçta tarayıcı, güvenliğin otomatik pilotu değil, yardımcı pilotudur. Kapsamı doğru tanımlamak, bulguları bağlamla değerlendirmek ve düzeltmeleri doğrulamak insan sorumluluğundadır. “Bulgu yok” ifadesi de “açık yok” garantisi vermez; yalnızca kullanılan kontrollerin o anda bir şey saptamadığını söyler.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="siber güvenlik" /><category term="zafiyet tarama" /><category term="cve" /><category term="cvss" /><category term="python" /><category term="güvenlik otomasyonu" /><summary type="html"><![CDATA[Bir zafiyet tarayıcısı, sunucunuza bakıp sihirli biçimde “Burada açık var!” diyen bir kristal küre değildir. Daha çok envanter çıkaran, ipuçlarını güvenlik duyurularıyla karşılaştıran ve şüpheli durumları raporlayan dijital bir dedektiftir. Peki bu dedektif hangi izleri takip eder, bulgularına ne kadar güvenebiliriz ve otomasyon nerede durmalıdır?]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/zafiyet-tarama-araclarinin-78.png" /><media:content medium="image" url="https://program.sonsuz.us/img/zafiyet-tarama-araclarinin-78.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>