<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.4.1">Jekyll</generator><link href="https://program.sonsuz.us/feed.xml" rel="self" type="application/atom+xml" /><link href="https://program.sonsuz.us/" rel="alternate" type="text/html" /><updated>2026-10-19T12:05:43+00:00</updated><id>https://program.sonsuz.us/feed.xml</id><title type="html">SonsuzUs</title><subtitle>Programlama ve Yazılım</subtitle><author><name>Sonsuz Us</name></author><entry><title type="html">C++’ta Const Borcu: İhmal Edilen const Doğruluğu Arayüzleri Nasıl Yaşlandırır?</title><link href="https://program.sonsuz.us/posts/cta-const-borcu-ihmal-edilen-const-dogrulugu-arayuzleri-nasil-yaslandirir/" rel="alternate" type="text/html" title="C++’ta Const Borcu: İhmal Edilen const Doğruluğu Arayüzleri Nasıl Yaşlandırır?" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/cta-const-borcu-ihmal-edilen-const-dogrulugu-arayuzleri-nasil-yaslandirir</id><content type="html" xml:base="https://program.sonsuz.us/posts/cta-const-borcu-ihmal-edilen-const-dogrulugu-arayuzleri-nasil-yaslandirir/"><![CDATA[<p>C++’ta <code class="language-plaintext highlighter-rouge">const</code>, yalnızca derleyiciyi memnun eden küçük bir anahtar kelime değildir; bir arayüzün hangi işlemleri garanti ettiğini anlatan sözleşmedir. Bugün atlanan bir <code class="language-plaintext highlighter-rouge">const</code>, kodu hemen bozmayabilir. Ancak proje büyüdükçe yeniden kullanım, eşzamanlılık ve geriye dönük uyumluluk gibi alanlarda faiz işleyen bir tasarım borcuna dönüşür.
``</p>
<h2 id="const-doğruluğu-gerçekte-ne-söyler">Const doğruluğu gerçekte ne söyler?</h2>

<p>Bir nesneye <code class="language-plaintext highlighter-rouge">const</code> erişim, gözlemlenebilir durumunun değiştirilmeyeceği sözünü verir. Üye fonksiyonun sonundaki <code class="language-plaintext highlighter-rouge">const</code> ise bu sözün fonksiyon arayüzündeki karşılığıdır:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">User</span> <span class="p">{</span>
<span class="nl">public:</span>
    <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">name</span><span class="p">()</span> <span class="k">const</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">name_</span><span class="p">;</span>
    <span class="p">}</span>

<span class="k">private</span><span class="o">:</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">name_</span><span class="p">;</span>
<span class="p">};</span>
</code></pre></div></div>

<p>Burada ilk <code class="language-plaintext highlighter-rouge">const</code>, döndürülen referans üzerinden metnin değiştirilemeyeceğini; ikinci <code class="language-plaintext highlighter-rouge">const</code> ise <code class="language-plaintext highlighter-rouge">name()</code> çağrısının <code class="language-plaintext highlighter-rouge">User</code> nesnesini değiştirmediğini belirtir. İki kullanım farklı soruları yanıtlar: “Sonuç değiştirilebilir mi?” ve “İşlem nesneyi değiştiriyor mu?”</p>

<p>Bunu kabaca bir durum geçişiyle ifade edebiliriz. Salt okunur işlem için beklenen ilişki:</p>

\[f(S) = (R, S)\]

<p>Burada $S$ nesnenin başlangıç durumu, $R$ sonuçtur. Değiştirici bir işlemdeyse yeni durum $S’$ oluşabilir:</p>

\[g(S) = (R, S'), \quad S' \neq S\]

<p><code class="language-plaintext highlighter-rouge">const</code>, ilk davranışı tür sistemi seviyesinde ilan eder ve derleyicinin bu sözleşmeyi denetlemesini sağlar.</p>

<h2 id="küçük-ihmal-büyük-arayüz-problemi">Küçük ihmal, büyük arayüz problemi</h2>

<p>Aşağıdaki fonksiyon nesneyi değiştirmese bile <code class="language-plaintext highlighter-rouge">const</code> olarak işaretlenmemiştir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">Report</span> <span class="p">{</span>
<span class="nl">public:</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">summary</span><span class="p">()</span> <span class="p">{</span> <span class="c1">// Aslında değişiklik yapmıyor</span>
        <span class="k">return</span> <span class="n">title_</span> <span class="o">+</span> <span class="s">": "</span> <span class="o">+</span> <span class="n">body_</span><span class="p">;</span>
    <span class="p">}</span>

<span class="k">private</span><span class="o">:</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">title_</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">body_</span><span class="p">;</span>
<span class="p">};</span>
</code></pre></div></div>

<p>Bu eksiklik yüzünden <code class="language-plaintext highlighter-rouge">const Report&amp;</code> alan kodlar <code class="language-plaintext highlighter-rouge">summary()</code> metodunu çağıramaz. Sorunu geçici olarak aşmak isteyen geliştiriciler nesneleri gereksiz yere kopyalayabilir, parametrelerden <code class="language-plaintext highlighter-rouge">const</code> niteliğini kaldırabilir veya daha kötüsü <code class="language-plaintext highlighter-rouge">const_cast</code> kullanabilir. Böylece yerel bir ihmal, çağrı zinciri boyunca yayılır.</p>

<table>
  <thead>
    <tr>
      <th>Tasarım tercihi</th>
      <th>Kısa vadeli sonuç</th>
      <th>Uzun vadeli etki</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Doğru <code class="language-plaintext highlighter-rouge">const</code> kullanımı</td>
      <td>Biraz daha dikkat gerektirir</td>
      <td>Açık sözleşme ve geniş kullanım alanı</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">const</code> kullanımını ertelemek</td>
      <td>Kod hızlı yazılır</td>
      <td>API esnekliği azalır</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">const_cast</code> ile aşmak</td>
      <td>Derleme hatası susturulur</td>
      <td>Tanımsız davranış ve bakım riski</td>
    </tr>
    <tr>
      <td>Her şeyi değiştirilebilir bırakmak</td>
      <td>Basit görünür</td>
      <td>Eşzamanlılık analizi zorlaşır</td>
    </tr>
  </tbody>
</table>

<h2 id="sonradan-eklemek-neden-pahalıdır">Sonradan eklemek neden pahalıdır?</h2>

<p>Bir metoda sonradan <code class="language-plaintext highlighter-rouge">const</code> eklemek kaynak kod düzeyinde küçük görünür:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">summary</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</code></pre></div></div>

<p>Fakat gerçek projede bu değişiklik; çağrılan yardımcı metotların, kullanılan işaretçilerin ve önbelleklerin de incelenmesini gerektirir. Ayrıca üye fonksiyonun <code class="language-plaintext highlighter-rouge">const</code> niteliği türünün parçasıdır. Sanal fonksiyonlarda taban ve türetilmiş sınıfların imzaları eşleşmelidir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="nc">Document</span> <span class="p">{</span>
    <span class="k">virtual</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">title</span><span class="p">()</span> <span class="k">const</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">};</span>

<span class="k">struct</span> <span class="nc">Invoice</span> <span class="o">:</span> <span class="n">Document</span> <span class="p">{</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">title</span><span class="p">()</span> <span class="k">const</span> <span class="k">override</span> <span class="p">{</span>
        <span class="k">return</span> <span class="s">"Fatura"</span><span class="p">;</span>
    <span class="p">}</span>
<span class="p">};</span>
</code></pre></div></div>

<p>Taban sınıfa sonradan <code class="language-plaintext highlighter-rouge">const</code> eklemek, bütün türetilmiş sınıfları değiştirebilir. Paylaşılan kütüphanelerde bu durum kaynak ve ikili uyumluluk planlarını da etkiler.</p>

<h2 id="mantıksal-const-ve-önbellekleme">Mantıksal const ve önbellekleme</h2>

<p>Bazen bir sorgu sonucu önbelleğe alınır. Kullanıcının gözünde nesne değişmezken içeride teknik bir güncelleme gerekir. Bunun için <code class="language-plaintext highlighter-rouge">mutable</code> bilinçli biçimde kullanılabilir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">Calculator</span> <span class="p">{</span>
<span class="nl">public:</span>
    <span class="kt">int</span> <span class="n">result</span><span class="p">()</span> <span class="k">const</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">cached_</span><span class="p">)</span> <span class="p">{</span>
            <span class="n">cache_</span> <span class="o">=</span> <span class="n">expensiveCalculation</span><span class="p">();</span>
            <span class="n">cached_</span> <span class="o">=</span> <span class="nb">true</span><span class="p">;</span>
        <span class="p">}</span>
        <span class="k">return</span> <span class="n">cache_</span><span class="p">;</span>
    <span class="p">}</span>

<span class="k">private</span><span class="o">:</span>
    <span class="kt">int</span> <span class="n">expensiveCalculation</span><span class="p">()</span> <span class="k">const</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">42</span><span class="p">;</span> <span class="p">}</span>
    <span class="k">mutable</span> <span class="kt">bool</span> <span class="n">cached_</span> <span class="o">=</span> <span class="nb">false</span><span class="p">;</span>
    <span class="k">mutable</span> <span class="kt">int</span> <span class="n">cache_</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">};</span>
</code></pre></div></div>

<p>Bu yaklaşım fiziksel değil, mantıksal değişmezliği temsil eder. Yine de <code class="language-plaintext highlighter-rouge">mutable</code>, eşzamanlı erişimi otomatik olarak güvenli yapmaz; gerekirse kilit veya atomik tür kullanılmalıdır.</p>

<h2 id="sağlam-arayüz-için-pratik-ölçüt">Sağlam arayüz için pratik ölçüt</h2>

<p>Bir metot tasarlarken önce “Bu işlem nesnenin kullanıcı tarafından gözlemlenen anlamını değiştiriyor mu?” diye sorun. Yanıt hayırsa metodu <code class="language-plaintext highlighter-rouge">const</code> yapın. Parametrelerde mümkün olduğunda <code class="language-plaintext highlighter-rouge">const T&amp;</code>, sahiplik aktarılmıyorsa salt okunur işaretçi veya görünüm türleri kullanın. <code class="language-plaintext highlighter-rouge">const</code> doğruluğunu baştan kurmak birkaç saniye; yıllar sonra bütün API ağında düzeltmek ise pahalı bir mimari operasyondur. Kısacası <code class="language-plaintext highlighter-rouge">const</code>, kısıtlama değil, gelecekteki kullanım biçimlerine açılan güvenli bir kapıdır.</p>

<p><img src="/img/cta-const-borcu-47.svg" alt="cta-const-borcu-47" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="c++" /><category term="const-correctness" /><category term="api-tasarımı" /><category term="yazılım-mimarisi" /><category term="teknik-borç" /><summary type="html"><![CDATA[C++’ta const, yalnızca derleyiciyi memnun eden küçük bir anahtar kelime değildir; bir arayüzün hangi işlemleri garanti ettiğini anlatan sözleşmedir. Bugün atlanan bir const, kodu hemen bozmayabilir. Ancak proje büyüdükçe yeniden kullanım, eşzamanlılık ve geriye dönük uyumluluk gibi alanlarda faiz işleyen bir tasarım borcuna dönüşür.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/cta-const-borcu-47.png" /><media:content medium="image" url="https://program.sonsuz.us/img/cta-const-borcu-47.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">C++’ta const Referanslar ve Geçici Nesne Ömrü: Sessiz Tuzaklar</title><link href="https://program.sonsuz.us/posts/cta-const-referanslar-ve-gecici-nesne-omru-sessiz-tuzaklar/" rel="alternate" type="text/html" title="C++’ta const Referanslar ve Geçici Nesne Ömrü: Sessiz Tuzaklar" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/cta-const-referanslar-ve-gecici-nesne-omru-sessiz-tuzaklar</id><content type="html" xml:base="https://program.sonsuz.us/posts/cta-const-referanslar-ve-gecici-nesne-omru-sessiz-tuzaklar/"><![CDATA[<p><img src="/img/cta-const-referanslar-21.svg" alt="cta-const-referanslar-21" /></p>

<p>C++’ta <code class="language-plaintext highlighter-rouge">const T&amp;</code> gördüğümüzde genellikle “güvenli, değiştirilemez referans” diye düşünürüz. Ancak geçici nesneler devreye girdiğinde konu yalnızca değiştirilebilirlikten ibaret değildir. Referansın neye, nerede ve nasıl bağlandığı; geçici nesnenin hemen yok edilmesini de kapsam sonuna kadar yaşamasını da sağlayabilir. Kısacası <code class="language-plaintext highlighter-rouge">const</code>, bazen nesneye adeta fazladan can verir.</p>

<p>``</p>

<h2 id="geçici-nesne-nedir">Geçici nesne nedir?</h2>

<p>Bir ifadenin sonucunu taşımak için oluşturulan, genellikle adı olmayan nesneye geçici nesne denir. Örneğin <code class="language-plaintext highlighter-rouge">std::string("merhaba")</code> bir geçici nesne üretir. Normal koşullarda bu nesne, içinde oluşturulduğu <strong>tam ifadenin</strong> sonunda yok edilir. Çoğu zaman bu nokta noktalı virgüldür.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"merhaba"</span><span class="p">);</span> <span class="c1">// Nesne bu satırın sonunda yok edilir.</span>
</code></pre></div></div>

<p>Basitleştirilmiş biçimde geçici nesnenin olağan ömrünü şöyle düşünebiliriz:</p>

\[L_{geçici} = t_{ifade\ sonu} - t_{oluşturma}\]

<p>Fakat uygun bir yerel referansa doğrudan bağlama yapılırsa ömür, referansın kapsamına kadar uzatılabilir:</p>

\[L_{uzatılmış} = t_{kapsam\ sonu} - t_{oluşturma}\]

<h2 id="const-referans-neden-özel"><code class="language-plaintext highlighter-rouge">const</code> referans neden özel?</h2>

<p>Lvalue referansları normalde geçici nesnelere bağlanamaz:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">a</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"C++"</span><span class="p">);</span> <span class="c1">// Hata</span>
</code></pre></div></div>

<p>Bunun nedeni, kısa ömürlü ve isimsiz bir değerin değiştirilebilir bir lvalue referansı üzerinden kullanılmasının riskli kabul edilmesidir. Buna karşılık <code class="language-plaintext highlighter-rouge">const</code> lvalue referansı bağlanabilir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">a</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"C++"</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">a</span><span class="p">;</span> <span class="c1">// Güvenli: geçicinin ömrü a'nın kapsamına uzatıldı.</span>
</code></pre></div></div>

<table>
  <thead>
    <tr>
      <th>Bağlama biçimi</th>
      <th style="text-align: right">Geçiciye bağlanır mı?</th>
      <th style="text-align: right">Ömür uzar mı?</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">T&amp;</code></td>
      <td style="text-align: right">Hayır</td>
      <td style="text-align: right">Hayır</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">const T&amp;</code></td>
      <td style="text-align: right">Evet</td>
      <td style="text-align: right">Genellikle evet</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">T&amp;&amp;</code></td>
      <td style="text-align: right">Evet</td>
      <td style="text-align: right">Yerel değişkense evet</td>
    </tr>
    <tr>
      <td>Fonksiyon parametresi <code class="language-plaintext highlighter-rouge">const T&amp;</code></td>
      <td style="text-align: right">Evet</td>
      <td style="text-align: right">Yalnızca çağrının tam ifadesinin sonuna kadar</td>
    </tr>
  </tbody>
</table>

<p>Son satır kritik bir ayrıntıdır. Bir fonksiyon parametresine bağlanan geçici, fonksiyon çağrısı bittikten sonra saklanamaz.</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">*</span> <span class="n">adres</span><span class="p">;</span>

<span class="kt">void</span> <span class="nf">sakla</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">metin</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">adres</span> <span class="o">=</span> <span class="o">&amp;</span><span class="n">metin</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">sakla</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"kaybolacak"</span><span class="p">));</span>
<span class="c1">// Bu noktadan sonra adres dangling pointer!</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">metin</code>, fonksiyon içinde geçerlidir; fakat çağrının bulunduğu tam ifade sona erince geçici nesne yok edilir.</p>

<h2 id="referansı-döndürmek-ömrü-uzatmaz">Referansı döndürmek ömrü uzatmaz</h2>

<p>En tehlikeli sürprizlerden biri, fonksiyondan <code class="language-plaintext highlighter-rouge">const</code> referans döndürmektir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="err">ü</span><span class="n">ret</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"geçici"</span><span class="p">);</span> <span class="c1">// Hatalı: yok edilecek nesneye referans</span>
<span class="p">}</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">const</code> burada koruyucu kalkan değildir. Fonksiyon sona erdiğinde geçici nesne yok edilir ve dönen referans boşa çıkar. Doğru yaklaşım değeri döndürmektir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="err">ü</span><span class="n">ret</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"güvenli"</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Modern C++, kopya eleme ve taşıma sayesinde bu kodu çoğunlukla ek maliyet oluşturmadan çalıştırır.</p>

<h2 id="i̇kinci-referans-ikinci-bir-ömür-vermez">İkinci referans ikinci bir ömür vermez</h2>

<p>Ömür uzatma aktarılabilir bir özellik değildir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">ilk</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"örnek"</span><span class="p">);</span>
<span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span> <span class="n">ikinci</span> <span class="o">=</span> <span class="n">ilk</span><span class="p">;</span>
</code></pre></div></div>

<p>Nesnenin ömrü <code class="language-plaintext highlighter-rouge">ilk</code> nedeniyle uzatılmıştır. <code class="language-plaintext highlighter-rouge">ikinci</code>, aynı nesneye başka bir takma ad verir; ömrü yeniden başlatmaz veya kendi kapsamına göre genişletmez. Eğer <code class="language-plaintext highlighter-rouge">ikinci</code>, <code class="language-plaintext highlighter-rouge">ilk</code>ten daha uzun yaşarsa dangling referansa dönüşebilir.</p>

<h2 id="const-dönüş-değeri-her-zaman-yararlı-değildir"><code class="language-plaintext highlighter-rouge">const</code> dönüş değeri her zaman yararlı değildir</h2>

<p>Eski kodlarda <code class="language-plaintext highlighter-rouge">const T</code> döndüren fonksiyonlar görülebilir:</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">olu</span><span class="err">ş</span><span class="n">tur</span><span class="p">();</span>
</code></pre></div></div>

<p>Bu kullanım, modern C++’ta taşıma işlemlerini engelleyebilir; çünkü taşıma kurucuları çoğunlukla <code class="language-plaintext highlighter-rouge">T&amp;&amp;</code> bekler, <code class="language-plaintext highlighter-rouge">const T&amp;&amp;</code> değil. Değer döndüren fonksiyonlarda genellikle yalnızca <code class="language-plaintext highlighter-rouge">T</code> tercih edilmelidir.</p>

<p>Özet kural şudur: Yerel <code class="language-plaintext highlighter-rouge">const T&amp;</code> ve <code class="language-plaintext highlighter-rouge">T&amp;&amp;</code>, doğrudan bağlandıkları geçicinin ömrünü uzatabilir. Parametreler, döndürülen referanslar ve başka bir referans üzerinden yapılan bağlamalar için aynı güvenceyi varsaymayın. <code class="language-plaintext highlighter-rouge">const</code>, değişikliği sınırlar; her durumda ömür yönetmez.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="c++" /><category term="const" /><category term="referanslar" /><category term="nesne-ömrü" /><category term="geçici-nesneler" /><category term="modern-c++" /><summary type="html"><![CDATA[C++’ta const T&amp; gördüğümüzde genellikle “güvenli, değiştirilemez referans” diye düşünürüz. Ancak geçici nesneler devreye girdiğinde konu yalnızca değiştirilebilirlikten ibaret değildir. Referansın neye, nerede ve nasıl bağlandığı; geçici nesnenin hemen yok edilmesini de kapsam sonuna kadar yaşamasını da sağlayabilir. Kısacası const, bazen nesneye adeta fazladan can verir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/cta-const-referanslar-21.png" /><media:content medium="image" url="https://program.sonsuz.us/img/cta-const-referanslar-21.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Diferansiyel Sürüşlü Robotlar Tekerlek Hızı Farkıyla Nasıl Döner?</title><link href="https://program.sonsuz.us/posts/diferansiyel-suruslu-robotlar-tekerlek-hizi-farkiyla-nasil-doner/" rel="alternate" type="text/html" title="Diferansiyel Sürüşlü Robotlar Tekerlek Hızı Farkıyla Nasıl Döner?" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/diferansiyel-suruslu-robotlar-tekerlek-hizi-farkiyla-nasil-doner</id><content type="html" xml:base="https://program.sonsuz.us/posts/diferansiyel-suruslu-robotlar-tekerlek-hizi-farkiyla-nasil-doner/"><![CDATA[<p>Diferansiyel sürüşlü bir robotun direksiyonu yoktur; buna rağmen kıvrak biçimde dönebilir, hatta olduğu yerde kendi ekseni etrafında dans edebilir. Bu yeteneğin sırrı, sağ ve sol tekerleklerin farklı hızlarda döndürülmesidir. Alışveriş arabasını tek taraftan daha güçlü ittiğinizi düşünün: hız farkı, aracın yönünü değiştirir.</p>

<p><img src="/img/diferansiyel-suruslu-robotlar-65.svg" alt="diferansiyel-suruslu-robotlar-65" /></p>

<p>``</p>
<h2 id="temel-mekanik-düzen">Temel mekanik düzen</h2>

<p>Bu robotlarda aynı eksen üzerinde bulunan iki bağımsız tahrik tekerleği vardır. Tekerlekler arasındaki mesafeye <strong>iz genişliği</strong> veya dingil uzunluğu denir ve genellikle $L$ ile gösterilir. Sol tekerleğin doğrusal hızı $v_l$, sağ tekerleğinki ise $v_r$ olsun.</p>

<p>Robotun merkezinin ileri yönlü doğrusal hızı iki tekerlek hızının ortalamasıdır:</p>

\[v = (v_r + v_l) / 2\]

<p>Açısal hız ise tekerlekler arasındaki hız farkıyla belirlenir:</p>

\[ω = (v_r - v_l) / L\]

<p>Bu ikinci denklem robotun dönüş mantığını özetler. Hız farkı büyüdükçe robot daha hızlı döner. Tekerlekler arası mesafe büyüdükçe aynı hız farkıyla elde edilen açısal hız azalır; çünkü geniş bir robotu çevirmek daha zordur.</p>

<table>
  <thead>
    <tr>
      <th>Sol ve sağ hız ilişkisi</th>
      <th>Robotun davranışı</th>
      <th style="text-align: right">Açısal hız</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>$v_l = v_r &gt; 0$</td>
      <td>Düz ileri gider</td>
      <td style="text-align: right">$0$</td>
    </tr>
    <tr>
      <td>$v_l &lt; v_r$</td>
      <td>Sola döner</td>
      <td style="text-align: right">Pozitif</td>
    </tr>
    <tr>
      <td>$v_l &gt; v_r$</td>
      <td>Sağa döner</td>
      <td style="text-align: right">Negatif</td>
    </tr>
    <tr>
      <td>$v_l = -v_r$</td>
      <td>Olduğu yerde döner</td>
      <td style="text-align: right">En yüksek</td>
    </tr>
    <tr>
      <td>$v_l = v_r = 0$</td>
      <td>Durur</td>
      <td style="text-align: right">$0$</td>
    </tr>
  </tbody>
</table>

<p>Buradaki sağ ve sol yön işaretleri, kullanılan koordinat sistemine göre ters tanımlanabilir. Önemli olan yazılımın ve matematiksel modelin aynı işaret kuralını kullanmasıdır.</p>

<h2 id="görünmez-dönüş-merkezi-icc">Görünmez dönüş merkezi: ICC</h2>

<p>Robot viraj alırken iki tekerlek aynı merkez çevresinde fakat farklı yarıçaplarda yay çizer. Bu ortak noktaya <strong>Anlık Dönüş Merkezi</strong> ya da ICC denir. İç taraftaki tekerlek daha kısa, dış taraftaki tekerlek daha uzun yol aldığı için dış tekerlek daha hızlı dönmelidir.</p>

<p>Robot merkezinin dönüş yarıçapı $R$, açısal hız sıfır değilken şöyle bulunabilir:</p>

\[R = v / ω = L(v_r + v_l) / (2(v_r - v_l))\]

<p>Tekerlek hızları birbirine yaklaştığında paydadaki fark küçülür ve $R$ büyür; robot geniş bir yay çizer. Hızlar eşit olduğunda yarıçap teorik olarak sonsuza gider, yani hareket düz bir çizgiye dönüşür. Hızlar eşit büyüklükte ve zıt yönlü olduğundaysa $v=0$ olur; dönüş merkezi robotun tam ortasına gelir.</p>

<h2 id="basit-bir-hız-hesabı">Basit bir hız hesabı</h2>

<p>Aşağıdaki Python fonksiyonu, tekerlek hızlarından robotun doğrusal ve açısal hızını hesaplar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">robot_hizi</span><span class="p">(</span><span class="n">sol_hiz</span><span class="p">,</span> <span class="n">sag_hiz</span><span class="p">,</span> <span class="n">tekerlek_araligi</span><span class="p">):</span>
    <span class="n">dogrusal_hiz</span> <span class="o">=</span> <span class="p">(</span><span class="n">sag_hiz</span> <span class="o">+</span> <span class="n">sol_hiz</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span>
    <span class="n">acisal_hiz</span> <span class="o">=</span> <span class="p">(</span><span class="n">sag_hiz</span> <span class="o">-</span> <span class="n">sol_hiz</span><span class="p">)</span> <span class="o">/</span> <span class="n">tekerlek_araligi</span>
    <span class="k">return</span> <span class="n">dogrusal_hiz</span><span class="p">,</span> <span class="n">acisal_hiz</span>

<span class="n">v</span><span class="p">,</span> <span class="n">omega</span> <span class="o">=</span> <span class="nf">robot_hizi</span><span class="p">(</span><span class="mf">0.20</span><span class="p">,</span> <span class="mf">0.40</span><span class="p">,</span> <span class="mf">0.30</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="n">omega</span><span class="p">)</span>
</code></pre></div></div>

<p>Bu örnekte robotun doğrusal hızı $0.30\ m/s$, açısal hızı yaklaşık $0.67\ rad/s$ olur. Sağ tekerlek daha hızlı olduğu için robot sola yönelir.</p>

<p>Motorlar genellikle doğrusal hız yerine açısal tekerlek hızıyla kontrol edilir. Tekerlek yarıçapı $r$ ve motor açısal hızı $ω_w$ ise doğrusal hız:</p>

\[v_w = rω_w\]

<p>bağıntısıyla bulunur. Böylece enkoderden ölçülen dönüş hızı, robot kinematiğinde kullanılabilir.</p>

<h2 id="gerçek-dünya-neden-formüllerden-daha-huysuzdur">Gerçek dünya neden formüllerden daha huysuzdur?</h2>

<p>Teorik model tekerleklerin kaymadığını varsayar. Gerçekte zemin sürtünmesi, motor farklılıkları, pil gerilimi ve ağırlık dağılımı dönüşü etkiler. Aynı PWM değeri iki motorda aynı hızı üretmeyebilir. Bu nedenle enkoder geri bildirimi ve PID kontrolü kullanılarak her tekerleğin hedef hızı ayrı ayrı korunur.</p>

<p>Kısacası diferansiyel sürüş, mekanik olarak sade fakat matematiksel olarak güçlüdür: ortalama hız robotu ilerletir, hız farkı ise döndürür. İki motorun uyumlu anlaşmazlığı, robotun tüm yön kabiliyetini oluşturur.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="robotik" /><category term="diferansiyel sürüş" /><category term="kinematik" /><category term="tekerlek hızı" /><category term="python" /><category term="mobil robotlar" /><summary type="html"><![CDATA[Diferansiyel sürüşlü bir robotun direksiyonu yoktur; buna rağmen kıvrak biçimde dönebilir, hatta olduğu yerde kendi ekseni etrafında dans edebilir. Bu yeteneğin sırrı, sağ ve sol tekerleklerin farklı hızlarda döndürülmesidir. Alışveriş arabasını tek taraftan daha güçlü ittiğinizi düşünün: hız farkı, aracın yönünü değiştirir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/diferansiyel-suruslu-robotlar-65.png" /><media:content medium="image" url="https://program.sonsuz.us/img/diferansiyel-suruslu-robotlar-65.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Fırtınada Bile Gören Robotlar: Otonom Araçlarda Sensör Füzyonu</title><link href="https://program.sonsuz.us/posts/firtinada-bile-goren-robotlar-otonom-araclarda-sensor-fuzyonu/" rel="alternate" type="text/html" title="Fırtınada Bile Gören Robotlar: Otonom Araçlarda Sensör Füzyonu" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/firtinada-bile-goren-robotlar-otonom-araclarda-sensor-fuzyonu</id><content type="html" xml:base="https://program.sonsuz.us/posts/firtinada-bile-goren-robotlar-otonom-araclarda-sensor-fuzyonu/"><![CDATA[<p>Güneşli bir günde yolu algılamak otonom araçlar için görece kolaydır. Ancak sis çöktüğünde, yağmur kamera görüntüsünü bozduğunda veya kar taneleri LiDAR ölçümlerinde hayalet noktalar oluşturduğunda işler değişir. Sensör füzyonu, farklı sensörlerin güçlü yanlarını birleştirerek aracın tek bir ölçüme körü körüne güvenmesini önler. Kısacası ekip çalışması yapar: Kamera renkleri söyler, radar mesafeyi ölçer, LiDAR çevrenin üç boyutlu haritasını çıkarır.</p>

<p><img src="/img/firtinada-bile-goren-83.svg" alt="firtinada-bile-goren-83" /></p>

<p>``</p>

<h2 id="tek-bir-sensör-neden-yetmez">Tek Bir Sensör Neden Yetmez?</h2>

<p>Her sensör çevreyi farklı bir fiziksel ilkeye göre gözlemler. Kameralar görünür ışığı, radar elektromanyetik dalgaların yansımasını, LiDAR ise lazer darbelerinin dönüş süresini kullanır. Bu çeşitlilik aynı zamanda hata çeşitliliği demektir. Kamera sisi yoğun bir duvar gibi görebilirken radar sisin içinden çalışmayı sürdürebilir. Buna karşılık radar, nesnenin bisiklet mi yoksa trafik levhası mı olduğunu kamera kadar başarılı sınıflandıramaz.</p>

<table>
  <thead>
    <tr>
      <th>Sensör</th>
      <th>Güçlü yönü</th>
      <th>Kötü havadaki sorunu</th>
      <th>Füzyondaki rolü</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Kamera</td>
      <td>Renk, şerit ve nesne sınıfı</td>
      <td>Sis, karanlık ve su damlaları</td>
      <td>Anlamsal bilgi sağlar</td>
    </tr>
    <tr>
      <td>LiDAR</td>
      <td>Hassas 3B geometri</td>
      <td>Yağmur ve karda sahte yansımalar</td>
      <td>Şekil ve konum üretir</td>
    </tr>
    <tr>
      <td>Radar</td>
      <td>Hız ve mesafe ölçümü</td>
      <td>Düşük açısal çözünürlük</td>
      <td>Zorlu havada kararlı ölçüm sağlar</td>
    </tr>
    <tr>
      <td>Ultrasonik</td>
      <td>Yakın mesafede ekonomiktir</td>
      <td>Rüzgâr ve yüzey yapısından etkilenir</td>
      <td>Park ve düşük hız desteği verir</td>
    </tr>
    <tr>
      <td>GNSS/IMU</td>
      <td>Araç konumu ve hareketi</td>
      <td>Tünel, yansıma ve sürüklenme</td>
      <td>Küresel ve göreli hareketi izler</td>
    </tr>
  </tbody>
</table>

<h2 id="güven-ağırlık-ve-olasılık">Güven, Ağırlık ve Olasılık</h2>

<p>Füzyonun temel fikri, bütün sensörlere eşit oy hakkı vermek değildir. Sistem, mevcut koşullara göre her ölçümün güvenilirliğini değerlendirir. Bir sensörün ölçümü $z_i$, güven ağırlığı $w_i$ ise basit bir birleşik tahmin şöyle yazılabilir:</p>

\[x = (w_1z_1 + w_2z_2 + ... + w_nz_n) / (w_1 + w_2 + ... + w_n)\]

<p>Yoğun siste kameranın $w$ değeri azaltılırken radarın ağırlığı artırılabilir. Daha gelişmiş sistemlerde Kalman filtresi, genişletilmiş Kalman filtresi, parçacık filtresi veya Bayesçi çıkarım kullanılır. Bayes yaklaşımı, yeni bir ölçüm geldiğinde önceki inancı günceller:</p>

\[P(x\vert z) = P(z\vert x)P(x) / P(z)\]

<p>Burada $P(x)$ önceki tahmini, $P(z\vert x)$ ölçümün bu tahmin altında görülme olasılığını, $P(x\vert z)$ ise güncellenmiş sonucu temsil eder. Böylece araç, “Radar önümde bir şey olduğunu söylüyor ama kamera emin değil” durumunu matematiksel olarak çözebilir.</p>

<h2 id="basit-bir-uyarlanabilir-füzyon-örneği">Basit Bir Uyarlanabilir Füzyon Örneği</h2>

<p>Aşağıdaki Python kodu, hava durumuna göre kamera ve radar ölçümlerinin ağırlıklarını değiştirir. Gerçek araçlarda belirsizlik kovaryans matrisleri ve zaman senkronizasyonu kullanılır; bu örnek temel mantığı görünür kılar.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">fuse_distance</span><span class="p">(</span><span class="n">camera</span><span class="p">,</span> <span class="n">radar</span><span class="p">,</span> <span class="n">weather</span><span class="p">):</span>
    <span class="c1"># Açık havada kamera daha güvenilirken siste radar öne çıkar.
</span>    <span class="n">weights</span> <span class="o">=</span> <span class="p">{</span>
        <span class="sh">"</span><span class="s">clear</span><span class="sh">"</span><span class="p">:</span> <span class="p">(</span><span class="mf">0.6</span><span class="p">,</span> <span class="mf">0.4</span><span class="p">),</span>
        <span class="sh">"</span><span class="s">rain</span><span class="sh">"</span><span class="p">:</span>  <span class="p">(</span><span class="mf">0.3</span><span class="p">,</span> <span class="mf">0.7</span><span class="p">),</span>
        <span class="sh">"</span><span class="s">fog</span><span class="sh">"</span><span class="p">:</span>   <span class="p">(</span><span class="mf">0.15</span><span class="p">,</span> <span class="mf">0.85</span><span class="p">)</span>
    <span class="p">}</span>

    <span class="n">camera_w</span><span class="p">,</span> <span class="n">radar_w</span> <span class="o">=</span> <span class="n">weights</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">weather</span><span class="p">,</span> <span class="p">(</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">))</span>
    <span class="k">return</span> <span class="n">camera</span> <span class="o">*</span> <span class="n">camera_w</span> <span class="o">+</span> <span class="n">radar</span> <span class="o">*</span> <span class="n">radar_w</span>

<span class="n">result</span> <span class="o">=</span> <span class="nf">fuse_distance</span><span class="p">(</span><span class="n">camera</span><span class="o">=</span><span class="mf">24.0</span><span class="p">,</span> <span class="n">radar</span><span class="o">=</span><span class="mf">21.5</span><span class="p">,</span> <span class="n">weather</span><span class="o">=</span><span class="sh">"</span><span class="s">fog</span><span class="sh">"</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Tahmini mesafe: </span><span class="si">{</span><span class="n">result</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"> metre</span><span class="sh">"</span><span class="p">)</span>
</code></pre></div></div>

<p>Burada sisli havada radar ölçümü sonuca daha fazla yön verir. Fakat yalnızca hava etiketi kullanmak yeterli değildir. Kamera kontrastı, LiDAR dönüş yoğunluğu, radar sinyal-gürültü oranı ve sensör sıcaklığı gibi anlık kalite göstergeleri de ağırlıkları dinamik biçimde değiştirmelidir.</p>

<h2 id="füzyonun-gizli-kahramanları">Füzyonun Gizli Kahramanları</h2>

<p>Başarılı bir sistem için sensörlerin kalibrasyonu ve zaman eşlemesi kritiktir. Milisaniyelik gecikme, hızlı hareket eden bir aracın farklı konumlarda algılanmasına yol açabilir. Ayrıca sensörler ortak koordinat sistemine dönüştürülmelidir. Aksi hâlde radarın “ön sağ” dediği nesne, kamera görüntüsünde yanlış piksele bağlanır.</p>

<p>Sonuç olarak sensör füzyonu kötü havayı ortadan kaldırmaz; belirsizliği yönetilebilir hâle getirir. Güvenilir otonomi, en parlak sensöre sahip olmak değil, hangi sensöre ne zaman güvenileceğini bilmektir. Robotik aracın süper gücü kusursuz görmek değil, şüphe etmeyi matematikle öğrenmektir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="robotik" /><category term="otonom araçlar" /><category term="sensör füzyonu" /><category term="lidar" /><category term="radar" /><category term="bilgisayarlı görü" /><category term="yapay zeka" /><summary type="html"><![CDATA[Güneşli bir günde yolu algılamak otonom araçlar için görece kolaydır. Ancak sis çöktüğünde, yağmur kamera görüntüsünü bozduğunda veya kar taneleri LiDAR ölçümlerinde hayalet noktalar oluşturduğunda işler değişir. Sensör füzyonu, farklı sensörlerin güçlü yanlarını birleştirerek aracın tek bir ölçüme körü körüne güvenmesini önler. Kısacası ekip çalışması yapar: Kamera renkleri söyler, radar mesafeyi ölçer, LiDAR çevrenin üç boyutlu haritasını çıkarır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/firtinada-bile-goren-83.png" /><media:content medium="image" url="https://program.sonsuz.us/img/firtinada-bile-goren-83.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">HRI Güvenliği: Robotlarla Teması Nasıl Daha Az Riskli Hâle Getiriyoruz?</title><link href="https://program.sonsuz.us/posts/hri-guvenligi-robotlarla-temasi-nasil-daha-az-riskli-hale-getiriyoruz/" rel="alternate" type="text/html" title="HRI Güvenliği: Robotlarla Teması Nasıl Daha Az Riskli Hâle Getiriyoruz?" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/hri-guvenligi-robotlarla-temasi-nasil-daha-az-riskli-hale-getiriyoruz</id><content type="html" xml:base="https://program.sonsuz.us/posts/hri-guvenligi-robotlarla-temasi-nasil-daha-az-riskli-hale-getiriyoruz/"><![CDATA[<p>İnsanlarla aynı çalışma alanını paylaşan robotlar artık yalnızca bilim kurgu filmlerinde değil; fabrikalarda, hastanelerde ve laboratuvarlarda karşımıza çıkıyor. Ancak bir robotun nazikçe kahve uzatmasıyla kontrolsüz biçimde kolumuza çarpması arasında ciddi bir güvenlik farkı var. İnsan-robot etkileşimi, yani HRI güvenlik standartları, bu farkı şansa bırakmak yerine temas olasılığını, çarpışma enerjisini ve uygulanabilecek kuvveti sistematik olarak sınırlandırır.
``</p>

<h2 id="standartlar-neden-gereklidir">Standartlar neden gereklidir?</h2>

<p>Robot güvenliğinde temel yaklaşım, “Çarpışma olursa dururuz” demek değildir. Öncelikle tehlike belirlenir, risk tahmin edilir ve tasarım yoluyla azaltılır. ISO 12100 bu genel risk değerlendirme mantığını sunarken ISO 10218 endüstriyel robot sistemlerine ilişkin güvenlik şartlarını tanımlar. İş birliğine dayalı uygulamalarda kullanılan ISO/TS 15066 ise insan vücudunun farklı bölgeleri için temas, basınç ve kuvvet değerlendirmelerine rehberlik eder.</p>

<p>Standartların izlediği hiyerarşi kabaca şöyledir:</p>

<ol>
  <li>Tehlikeyi mümkünse tasarımdan kaldırmak.</li>
  <li>Hızı, kuvveti ve hareket alanını sınırlandırmak.</li>
  <li>Sensörler ve güvenlik fonksiyonları kullanmak.</li>
  <li>Kalan riskleri kullanıcıya bildirmek ve eğitim sağlamak.</li>
</ol>

<p>Buradaki önemli ayrıntı şudur: Üzerinde “cobot” etiketi bulunan bir robot kendiliğinden güvenli değildir. Robot, uç efektör, taşınan parça, çalışma hızı ve çevredeki yüzeyler birlikte değerlendirilmelidir. Yumuşak robot kolu sivri bir metal parça taşıyorsa güvenlik hikâyesinin kötü karakteri o parça olabilir.</p>

<h2 id="dört-temel-iş-birliği-yaklaşımı">Dört temel iş birliği yaklaşımı</h2>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Çalışma mantığı</th>
      <th>Temas riskini azaltma yöntemi</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Güvenlik dereceli izlemeli duruş</td>
      <td>İnsan ortak alana girdiğinde robot durur</td>
      <td>Hareketli robotla teması önler</td>
    </tr>
    <tr>
      <td>Elle yönlendirme</td>
      <td>Kullanıcı robotu kontrollü biçimde hareket ettirir</td>
      <td>Hız ve hareket yetkisini sınırlar</td>
    </tr>
    <tr>
      <td>Hız ve mesafe izleme</td>
      <td>İnsan yaklaştıkça robot yavaşlar</td>
      <td>Çarpışmadan önce güvenli duruş sağlar</td>
    </tr>
    <tr>
      <td>Güç ve kuvvet sınırlama</td>
      <td>Temas algılandığında kuvvet sınırlandırılır</td>
      <td>Yaralanma şiddetini azaltır</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/hri-guvenligi-robotlarla-97.svg" alt="hri-guvenligi-robotlarla-97" /></p>

<p>Hız ve mesafe izleme yaklaşımında robotun yalnızca mevcut konumu değil, durmak için ihtiyaç duyduğu alan da önemlidir. Basitleştirilmiş durma mesafesi şöyle düşünülebilir:</p>

\[S = vT + \frac{v^2}{2a} + C\]

<p>Burada $v$ robot hızı, $T$ algılama ve kontrol gecikmesi, $a$ frenleme ivmesi, $C$ ise sensör belirsizliği ve güvenlik payıdır. Hız iki katına çıktığında frenleme bölümünün dört kat büyümesi, hızlı robotların neden daha geniş güvenlik mesafesine ihtiyaç duyduğunu açıklar.</p>

<p>Çarpışmada taşınan enerji de önemlidir:</p>

\[E_k = \frac{1}{2}mv^2\]

<p>Etkili kütle $m$ aynı kalsa bile hızdaki küçük artışlar temas enerjisini belirgin biçimde yükseltir. Bu nedenle güvenlik sistemleri çoğu zaman insan yaklaştıkça hızı kademeli azaltır.</p>

<h2 id="basit-bir-hız-sınırlandırma-mantığı">Basit bir hız sınırlandırma mantığı</h2>

<p>Aşağıdaki örnek, ölçülen insan-robot mesafesine göre hız komutu üretir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">guvenli_hiz</span><span class="p">(</span><span class="n">mesafe</span><span class="p">,</span> <span class="n">azami_hiz</span><span class="o">=</span><span class="mf">1.0</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">mesafe</span> <span class="o">&lt;</span> <span class="mf">0.4</span><span class="p">:</span>
        <span class="k">return</span> <span class="mf">0.0</span>       <span class="c1"># Tehlikeli yakınlık: dur
</span>    <span class="k">if</span> <span class="n">mesafe</span> <span class="o">&lt;</span> <span class="mf">1.0</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">azami_hiz</span> <span class="o">*</span> <span class="p">(</span><span class="n">mesafe</span> <span class="o">-</span> <span class="mf">0.4</span><span class="p">)</span> <span class="o">/</span> <span class="mf">0.6</span>
    <span class="k">return</span> <span class="n">azami_hiz</span>

<span class="n">robot_hizi</span> <span class="o">=</span> <span class="nf">guvenli_hiz</span><span class="p">(</span><span class="n">sensor_mesafesi</span><span class="p">)</span>
</code></pre></div></div>

<p>Bu kod öğretici bir modeldir; gerçek bir güvenlik fonksiyonu değildir. Endüstriyel uygulamalarda sıradan kamera, işletim sistemi veya Python betiği tek başına yeterli kabul edilmez. Güvenlik dereceli sensörler, yedekli kontrol kanalları, hata teşhisi ve ISO 13849 gibi standartlara göre doğrulanmış performans seviyeleri gerekir.</p>

<h2 id="temasın-türü-de-sonucu-değiştirir">Temasın türü de sonucu değiştirir</h2>

<p>Standartlar geçici temas ile sıkışmalı teması ayırır. Robotun çarpıp geri çekildiği geçici temas kısa sürebilir; insanın robot ile duvar arasında sıkıştığı yarı statik temas ise daha tehlikelidir. Ayrıca baş, boyun ve göğüs gibi bölgelerin toleransı kol veya elden farklıdır. Bu nedenle tek bir evrensel kuvvet sınırı kullanmak yerine vücut bölgesi, temas alanı, süre ve basınç birlikte incelenir.</p>

<p>Sonuç olarak HRI güvenliği, robota dev bir acil durdurma düğmesi takmaktan ibaret değildir. Güvenli tasarım; mekanik yapı, sensörler, yazılım, doğrulama testleri ve insan davranışının ortak ürünüdür. İyi uygulanmış standartlar teması tamamen yok etmeyebilir, fakat temasın oluşma ihtimalini ve gerçekleştiğinde vereceği zararı ölçülebilir biçimde azaltır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="robotik" /><category term="hri" /><category term="iş güvenliği" /><category term="iso standartları" /><category term="cobot" /><category term="risk analizi" /><summary type="html"><![CDATA[İnsanlarla aynı çalışma alanını paylaşan robotlar artık yalnızca bilim kurgu filmlerinde değil; fabrikalarda, hastanelerde ve laboratuvarlarda karşımıza çıkıyor. Ancak bir robotun nazikçe kahve uzatmasıyla kontrolsüz biçimde kolumuza çarpması arasında ciddi bir güvenlik farkı var. İnsan-robot etkileşimi, yani HRI güvenlik standartları, bu farkı şansa bırakmak yerine temas olasılığını, çarpışma enerjisini ve uygulanabilecek kuvveti sistematik olarak sınırlandırır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/hri-guvenligi-robotlarla-97.png" /><media:content medium="image" url="https://program.sonsuz.us/img/hri-guvenligi-robotlarla-97.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Java Veri Tipleri, Değişkenler ve Diziler: Tip Güvenliğine Sağlam Bir Başlangıç</title><link href="https://program.sonsuz.us/posts/java-veri-tipleri-degiskenler-ve-diziler-tip-guvenligine-saglam-bir-baslangic/" rel="alternate" type="text/html" title="Java Veri Tipleri, Değişkenler ve Diziler: Tip Güvenliğine Sağlam Bir Başlangıç" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/java-veri-tipleri-degiskenler-ve-diziler-tip-guvenligine-saglam-bir-baslangic</id><content type="html" xml:base="https://program.sonsuz.us/posts/java-veri-tipleri-degiskenler-ve-diziler-tip-guvenligine-saglam-bir-baslangic/"><![CDATA[<p>Java’da her verinin bir kimliği vardır: tipi! Bir değişkenin sayı mı, karakter mi yoksa mantıksal değer mi taşıyacağı önceden belirtilir. Bu yaklaşım başlangıçta biraz katı görünse de hataların daha kod çalışmadan yakalanmasını sağlar. Gelin Java’nın tip güvenliği dünyasına, değişkenlerine ve aynı türden verileri düzenleyen dizilerine yakından bakalım.
``</p>

<h2 id="java-neden-katı-tipli-bir-dildir">Java Neden Katı Tipli Bir Dildir?</h2>

<p>Java, <strong>statik ve güçlü tipli</strong> bir programlama dilidir. Statik tipleme, değişken tiplerinin derleme aşamasında bilinmesi anlamına gelir. Güçlü tipleme ise uyumsuz tipler arasında kontrolsüz işlem yapılmasını engeller.</p>

<p>Örneğin aşağıdaki kod derlenemez:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="n">yas</span> <span class="o">=</span> <span class="mi">25</span><span class="o">;</span>
<span class="n">yas</span> <span class="o">=</span> <span class="s">"yirmi beş"</span><span class="o">;</span> <span class="c1">// Hata: String, int değişkenine atanamaz</span>
</code></pre></div></div>

<p>Derleyicinin bu itirazı aslında dostça bir uyarıdır. Aksi hâlde program, çalışma sırasında beklenmedik sonuçlarla karşılaşabilirdi. Tip güvenliği sayesinde bir değişkenin hangi değerleri taşıyabileceği ve üzerinde hangi işlemlerin uygulanabileceği bellidir.</p>

<h2 id="i̇lkel-veri-tipleri">İlkel Veri Tipleri</h2>

<p>Java’da doğrudan değer saklayan sekiz adet <strong>primitive</strong>, yani ilkel veri tipi bulunur. Bunlar nesne değildir ve genellikle hızlı, düşük maliyetli veri işlemleri için kullanılır.</p>

<table>
  <thead>
    <tr>
      <th>Tip</th>
      <th style="text-align: right">Boyut</th>
      <th>Örnek</th>
      <th>Kullanım amacı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">byte</code></td>
      <td style="text-align: right">8 bit</td>
      <td><code class="language-plaintext highlighter-rouge">120</code></td>
      <td>Küçük tam sayılar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">short</code></td>
      <td style="text-align: right">16 bit</td>
      <td><code class="language-plaintext highlighter-rouge">30000</code></td>
      <td>Orta aralıklı tam sayılar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">int</code></td>
      <td style="text-align: right">32 bit</td>
      <td><code class="language-plaintext highlighter-rouge">42</code></td>
      <td>Genel tam sayı işlemleri</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">long</code></td>
      <td style="text-align: right">64 bit</td>
      <td><code class="language-plaintext highlighter-rouge">9000L</code></td>
      <td>Büyük tam sayılar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">float</code></td>
      <td style="text-align: right">32 bit</td>
      <td><code class="language-plaintext highlighter-rouge">3.14F</code></td>
      <td>Düşük hassasiyetli ondalık sayılar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">double</code></td>
      <td style="text-align: right">64 bit</td>
      <td><code class="language-plaintext highlighter-rouge">3.14159</code></td>
      <td>Yüksek hassasiyetli ondalık sayılar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">char</code></td>
      <td style="text-align: right">16 bit</td>
      <td><code class="language-plaintext highlighter-rouge">'A'</code></td>
      <td>Tek bir Unicode karakteri</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">boolean</code></td>
      <td style="text-align: right">JVM’e bağlı</td>
      <td><code class="language-plaintext highlighter-rouge">true</code></td>
      <td>Doğru veya yanlış durumu</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/java-veri-tipleri-59.svg" alt="java-veri-tipleri-59" /></p>

<p>$n$ bitlik işaretli bir tam sayının teorik değer aralığı şu şekilde hesaplanır:</p>

\[-2^{n-1} \leq x \leq 2^{n-1}-1\]

<p>Dolayısıyla 8 bitlik <code class="language-plaintext highlighter-rouge">byte</code>, $-128$ ile $127$ arasında değer alabilir. Daha büyük bir değer atamaya çalışmak derleme hatasına neden olur.</p>

<h2 id="değişken-tanımlama-ve-tür-dönüşümü">Değişken Tanımlama ve Tür Dönüşümü</h2>

<p>Bir değişken; tip, isim ve isteğe bağlı başlangıç değerinden oluşur:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="n">ogrenciSayisi</span> <span class="o">=</span> <span class="mi">24</span><span class="o">;</span>
<span class="kt">double</span> <span class="n">sicaklik</span> <span class="o">=</span> <span class="mf">21.5</span><span class="o">;</span>
<span class="kt">char</span> <span class="n">seviye</span> <span class="o">=</span> <span class="sc">'A'</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">aktifMi</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
</code></pre></div></div>

<p>Küçük kapsamlı bir tipten daha geniş kapsamlı tipe geçiş çoğunlukla otomatik yapılır. Buna <strong>widening conversion</strong> denir. Tersi yönde ise veri kaybı oluşabileceği için açık dönüşüm gerekir.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="n">puan</span> <span class="o">=</span> <span class="mi">95</span><span class="o">;</span>
<span class="kt">double</span> <span class="n">ondalikliPuan</span> <span class="o">=</span> <span class="n">puan</span><span class="o">;</span> <span class="c1">// Otomatik dönüşüm</span>

<span class="kt">double</span> <span class="n">fiyat</span> <span class="o">=</span> <span class="mf">49.99</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">tamFiyat</span> <span class="o">=</span> <span class="o">(</span><span class="kt">int</span><span class="o">)</span> <span class="n">fiyat</span><span class="o">;</span>   <span class="c1">// Açık dönüşüm: sonuç 49</span>
</code></pre></div></div>

<table>
  <thead>
    <tr>
      <th>Dönüşüm</th>
      <th>Örnek</th>
      <th>Risk</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Genişletme</td>
      <td><code class="language-plaintext highlighter-rouge">int</code> → <code class="language-plaintext highlighter-rouge">double</code></td>
      <td>Genellikle güvenli</td>
    </tr>
    <tr>
      <td>Daraltma</td>
      <td><code class="language-plaintext highlighter-rouge">double</code> → <code class="language-plaintext highlighter-rouge">int</code></td>
      <td>Hassasiyet veya veri kaybı</td>
    </tr>
  </tbody>
</table>

<h2 id="diziler-aynı-tipten-verilerin-takımı">Diziler: Aynı Tipten Verilerin Takımı</h2>

<p>Dizi, aynı veri tipindeki birden fazla değeri sabit uzunlukta saklar. Java dizileri nesnedir; ancak içlerinde ilkel değerler veya nesne referansları bulunabilir.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span><span class="o">[]</span> <span class="n">notlar</span> <span class="o">=</span> <span class="o">{</span><span class="mi">85</span><span class="o">,</span> <span class="mi">90</span><span class="o">,</span> <span class="mi">72</span><span class="o">,</span> <span class="mi">100</span><span class="o">};</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">notlar</span><span class="o">[</span><span class="mi">0</span><span class="o">]);</span> <span class="c1">// 85</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">notlar</span><span class="o">.</span><span class="na">length</span><span class="o">);</span> <span class="c1">// 4</span>
</code></pre></div></div>

<p>Dizi indeksleri sıfırdan başlar. Uzunluğu $n$ olan bir dizinin geçerli indeks aralığı $0$ ile $n-1$ arasındadır. Bu sınırın dışına çıkılması <code class="language-plaintext highlighter-rouge">ArrayIndexOutOfBoundsException</code> üretir.</p>

<p>Diziler sonradan da oluşturulabilir:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">String</span><span class="o">[]</span> <span class="n">diller</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">String</span><span class="o">[</span><span class="mi">3</span><span class="o">];</span>
<span class="n">diller</span><span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="o">=</span> <span class="s">"Java"</span><span class="o">;</span>
<span class="n">diller</span><span class="o">[</span><span class="mi">1</span><span class="o">]</span> <span class="o">=</span> <span class="s">"Kotlin"</span><span class="o">;</span>
<span class="n">diller</span><span class="o">[</span><span class="mi">2</span><span class="o">]</span> <span class="o">=</span> <span class="s">"Python"</span><span class="o">;</span>

<span class="k">for</span> <span class="o">(</span><span class="nc">String</span> <span class="n">dil</span> <span class="o">:</span> <span class="n">diller</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">dil</span><span class="o">);</span>
<span class="o">}</span>
</code></pre></div></div>

<p>Buradaki geliştirilmiş <code class="language-plaintext highlighter-rouge">for</code> döngüsü, indeks yönetmeden her elemanı sırayla okur. Dizinin uzunluğu oluşturulduktan sonra değişmez; dinamik boyut gerekiyorsa <code class="language-plaintext highlighter-rouge">ArrayList</code> tercih edilir.</p>

<p>Sonuç olarak Java’nın katı tip sistemi, programcıyı kısıtlamak için değil güvenilir kod üretmeye yönlendirmek için vardır. Doğru veri tipini seçmek belleği ve niyeti netleştirirken diziler, benzer verileri düzenli biçimde yönetmenin temelini oluşturur.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="java" /><category term="veri tipleri" /><category term="değişkenler" /><category term="diziler" /><category term="tip güvenliği" /><category term="programlama" /><summary type="html"><![CDATA[Java’da her verinin bir kimliği vardır: tipi! Bir değişkenin sayı mı, karakter mi yoksa mantıksal değer mi taşıyacağı önceden belirtilir. Bu yaklaşım başlangıçta biraz katı görünse de hataların daha kod çalışmadan yakalanmasını sağlar. Gelin Java’nın tip güvenliği dünyasına, değişkenlerine ve aynı türden verileri düzenleyen dizilerine yakından bakalım.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/java-veri-tipleri-59.png" /><media:content medium="image" url="https://program.sonsuz.us/img/java-veri-tipleri-59.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Python’da *args ve **kwargs: Esneklik Okunabilirliğe Karşı</title><link href="https://program.sonsuz.us/posts/pythonda-args-ve-kwargs-esneklik-okunabilirlige-karsi/" rel="alternate" type="text/html" title="Python’da *args ve **kwargs: Esneklik Okunabilirliğe Karşı" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/pythonda-args-ve-kwargs-esneklik-okunabilirlige-karsi</id><content type="html" xml:base="https://program.sonsuz.us/posts/pythonda-args-ve-kwargs-esneklik-okunabilirlige-karsi/"><![CDATA[<p><img src="/img/pythonda-args-ve-31.svg" alt="pythonda-args-ve-31" /></p>

<p>Python’daki <code class="language-plaintext highlighter-rouge">*args</code> ve <code class="language-plaintext highlighter-rouge">**kwargs</code>, fonksiyonlara değişken sayıda argüman gönderme özgürlüğü sağlar. Ancak bu özgürlük kontrolsüz kullanıldığında fonksiyon imzası, ne beklediğini söylemeyen gizemli bir kapıya dönüşebilir. Fonksiyon çalışır, testler geçer; fakat onu ilk kez gören geliştirici kendini “Buraya ne göndermem gerekiyor?” diye sorarken bulur.</p>

<p>``</p>

<h2 id="args-ve-kwargs-aslında-ne-yapar"><code class="language-plaintext highlighter-rouge">*args</code> ve <code class="language-plaintext highlighter-rouge">**kwargs</code> aslında ne yapar?</h2>

<p><code class="language-plaintext highlighter-rouge">*args</code>, fazladan konumsal argümanları bir <code class="language-plaintext highlighter-rouge">tuple</code> içerisinde toplar. <code class="language-plaintext highlighter-rouge">**kwargs</code> ise fazladan anahtar kelimeli argümanları bir <code class="language-plaintext highlighter-rouge">dict</code> olarak saklar. Buradaki <code class="language-plaintext highlighter-rouge">args</code> ve <code class="language-plaintext highlighter-rouge">kwargs</code> isimleri zorunlu değildir; özel davranışı oluşturan yıldızlardır.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">rapor_olustur</span><span class="p">(</span><span class="n">baslik</span><span class="p">,</span> <span class="o">*</span><span class="n">satirlar</span><span class="p">,</span> <span class="o">**</span><span class="n">ayarlar</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">Rapor: </span><span class="si">{</span><span class="n">baslik</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Satır sayısı: </span><span class="si">{</span><span class="nf">len</span><span class="p">(</span><span class="n">satirlar</span><span class="p">)</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Ayarlar: </span><span class="si">{</span><span class="n">ayarlar</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>

<span class="nf">rapor_olustur</span><span class="p">(</span>
    <span class="sh">"</span><span class="s">Aylık Satış</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">Ocak: 120</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">Şubat: 145</span><span class="sh">"</span><span class="p">,</span>
    <span class="n">renk</span><span class="o">=</span><span class="sh">"</span><span class="s">mavi</span><span class="sh">"</span><span class="p">,</span>
    <span class="n">pdf</span><span class="o">=</span><span class="bp">True</span>
<span class="p">)</span>
</code></pre></div></div>

<p>Bu örnekte <code class="language-plaintext highlighter-rouge">satirlar</code>, iki elemanlı bir tuple; <code class="language-plaintext highlighter-rouge">ayarlar</code> ise <code class="language-plaintext highlighter-rouge">renk</code> ve <code class="language-plaintext highlighter-rouge">pdf</code> anahtarlarını taşıyan bir sözlüktür. Teknik olarak oldukça kullanışlıdır. Sorun, fonksiyon imzasının hangi ayarların geçerli olduğunu açıklamamasıdır.</p>

<p>Bir fonksiyonun anlaşılabilirliğini kabaca şu ilişkiyle düşünebiliriz:</p>

\[O \approx \frac{B}{1 + G}\]

<p>Burada $O$ okunabilirliği, $B$ imzada açıkça belirtilen bilgiyi, $G$ ise gizli veya belirsiz parametre sayısını temsil eder. Bu gerçek bir yazılım metriği değildir; fakat önemli fikri gösterir: Beklentiler imzadan sözlük içine taşındıkça okunabilirlik azalır.</p>

<h2 id="açık-imza-ile-karşılaştırma">Açık imza ile karşılaştırma</h2>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Avantaj</th>
      <th>Dezavantaj</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Açık parametreler</td>
      <td>IDE desteği ve anlaşılır hata mesajları</td>
      <td>Çok sayıda parametrede imza uzar</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">*args</code></td>
      <td>Değişken sayıda değer kabul eder</td>
      <td>Değerlerin anlamı sıraya bağımlıdır</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">**kwargs</code></td>
      <td>Yeni seçenek eklemek kolaydır</td>
      <td>Geçerli anahtarlar görünmez kalabilir</td>
    </tr>
    <tr>
      <td>Yapılandırma nesnesi</td>
      <td>Tip güvenliği ve düzen sağlar</td>
      <td>Ek bir sınıf tanımlamak gerekir</td>
    </tr>
  </tbody>
</table>

<p>Şu fonksiyon kısa görünür, ancak kullanıcı açısından yeterince açıklayıcı değildir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">kullanici_olustur</span><span class="p">(</span><span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
    <span class="c1"># Parametreleri doğrudan veri katmanına iletiyor.
</span>    <span class="k">return</span> <span class="n">veritabani</span><span class="p">.</span><span class="nf">ekle</span><span class="p">(</span><span class="n">kwargs</span><span class="p">)</span>
</code></pre></div></div>

<p>Fonksiyon <code class="language-plaintext highlighter-rouge">ad</code>, <code class="language-plaintext highlighter-rouge">eposta</code>, <code class="language-plaintext highlighter-rouge">yas</code> veya bambaşka alanlar mı bekliyor? Yanlışlıkla <code class="language-plaintext highlighter-rouge">eposta</code> yerine <code class="language-plaintext highlighter-rouge">epost</code> yazılırsa hata hemen mi alınacak, yoksa problem veritabanına kadar mı ilerleyecek? Kısa imza her zaman sade tasarım anlamına gelmez.</p>

<p>Açık parametreler çoğu durumda daha güvenlidir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">kullanici_olustur</span><span class="p">(</span>
    <span class="n">ad</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
    <span class="n">eposta</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
    <span class="o">*</span><span class="p">,</span>
    <span class="n">aktif</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="bp">True</span>
<span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">dict</span><span class="p">:</span>
    <span class="k">return</span> <span class="p">{</span>
        <span class="sh">"</span><span class="s">ad</span><span class="sh">"</span><span class="p">:</span> <span class="n">ad</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">eposta</span><span class="sh">"</span><span class="p">:</span> <span class="n">eposta</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">aktif</span><span class="sh">"</span><span class="p">:</span> <span class="n">aktif</span><span class="p">,</span>
    <span class="p">}</span>
</code></pre></div></div>

<p>Tek başına kullanılan <code class="language-plaintext highlighter-rouge">*</code>, sonraki parametrelerin yalnızca isimleriyle gönderilmesini zorunlu kılar. Böylece <code class="language-plaintext highlighter-rouge">aktif</code> değerinin yanlışlıkla üçüncü konumsal argüman olarak verilmesi engellenir. Ayrıca IDE otomatik tamamlama sunabilir ve statik tip denetleyicileri hataları daha erken yakalayabilir.</p>

<h2 id="yapılandırma-nesnesi-ne-zaman-kullanılmalı">Yapılandırma nesnesi ne zaman kullanılmalı?</h2>

<p>Seçenek sayısı arttığında bütün bilgileri <code class="language-plaintext highlighter-rouge">**kwargs</code> içine saklamak yerine <code class="language-plaintext highlighter-rouge">dataclass</code> tercih edilebilir:</p>

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

<span class="nd">@dataclass</span>
<span class="k">class</span> <span class="nc">RaporAyarlari</span><span class="p">:</span>
    <span class="n">renk</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="sh">"</span><span class="s">mavi</span><span class="sh">"</span>
    <span class="n">pdf</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="bp">False</span>
    <span class="n">sayfa_boyutu</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="sh">"</span><span class="s">A4</span><span class="sh">"</span>


<span class="k">def</span> <span class="nf">rapor_olustur</span><span class="p">(</span><span class="n">baslik</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">ayarlar</span><span class="p">:</span> <span class="n">RaporAyarlari</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="bp">None</span><span class="p">:</span>
    <span class="nf">print</span><span class="p">(</span><span class="n">baslik</span><span class="p">,</span> <span class="n">ayarlar</span><span class="p">)</span>
</code></pre></div></div>

<p>Bu yapı geçerli seçenekleri görünür kılar, varsayılan değerleri tek yerde toplar ve yanlış alan adlarının sessizce dolaşmasını önler.</p>

<p>Elbette <code class="language-plaintext highlighter-rouge">*args</code> ve <code class="language-plaintext highlighter-rouge">**kwargs</code> kötü değildir. Dekoratörlerde, başka bir fonksiyona çağrı aktarırken veya gerçekten değişken sayıda değer kabul eden toplama benzeri işlemlerde son derece uygundurlar. Temel ölçüt şudur: Esnekliğin kendisi fonksiyonun amacıysa yıldızlı parametreler mantıklıdır; yalnızca uzun bir imzayı saklamak için kullanılıyorsa okunabilirlik borcu oluştururlar. Python bize yıldızları verir, fakat her fonksiyonu galaksiye çevirmek zorunda değiliz.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="python" /><category term="args" /><category term="kwargs" /><category term="fonksiyonlar" /><category term="okunabilirlik" /><category term="temiz-kod" /><summary type="html"><![CDATA[Python’daki *args ve **kwargs, fonksiyonlara değişken sayıda argüman gönderme özgürlüğü sağlar. Ancak bu özgürlük kontrolsüz kullanıldığında fonksiyon imzası, ne beklediğini söylemeyen gizemli bir kapıya dönüşebilir. Fonksiyon çalışır, testler geçer; fakat onu ilk kez gören geliştirici kendini “Buraya ne göndermem gerekiyor?” diye sorarken bulur.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/pythonda-args-ve-31.png" /><media:content medium="image" url="https://program.sonsuz.us/img/pythonda-args-ve-31.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Python’da Late Binding: Döngüdeki Lambda’lar Neden Hep Son Değeri Görür?</title><link href="https://program.sonsuz.us/posts/pythonda-late-binding-dongudeki-lambdalar-neden-hep-son-degeri-gorur/" rel="alternate" type="text/html" title="Python’da Late Binding: Döngüdeki Lambda’lar Neden Hep Son Değeri Görür?" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/pythonda-late-binding-dongudeki-lambdalar-neden-hep-son-degeri-gorur</id><content type="html" xml:base="https://program.sonsuz.us/posts/pythonda-late-binding-dongudeki-lambdalar-neden-hep-son-degeri-gorur/"><![CDATA[<p>Bir döngü içinde birkaç <code class="language-plaintext highlighter-rouge">lambda</code> oluşturup her birinin farklı değeri hatırlamasını beklersiniz. Ardından hepsi aynı sonucu döndürür ve Python masumca size bakar. Bu davranış bir hata değil; closure’ların değişkenleri nasıl bağladığıyla ilgili önemli bir Python kuralıdır.</p>

<p>``</p>

<h2 id="şaşırtıcı-örnek">Şaşırtıcı örnek</h2>

<p>Aşağıdaki kodun <code class="language-plaintext highlighter-rouge">0, 1, 2</code> yazdırmasını beklemek oldukça doğaldır:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">fonksiyonlar</span> <span class="o">=</span> <span class="p">[]</span>

<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">3</span><span class="p">):</span>
    <span class="n">fonksiyonlar</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="k">lambda</span><span class="p">:</span> <span class="n">i</span><span class="p">)</span>

<span class="k">for</span> <span class="n">fonksiyon</span> <span class="ow">in</span> <span class="n">fonksiyonlar</span><span class="p">:</span>
    <span class="nf">print</span><span class="p">(</span><span class="nf">fonksiyon</span><span class="p">())</span>
</code></pre></div></div>

<p>Gerçek çıktı şöyledir:</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>2
2
2
</code></pre></div></div>

<p>Çünkü <code class="language-plaintext highlighter-rouge">lambda</code>, oluşturulduğu anda <code class="language-plaintext highlighter-rouge">i</code> değişkeninin değerini kopyalamaz. Bunun yerine, çevresindeki kapsamda bulunan <code class="language-plaintext highlighter-rouge">i</code> değişkenine erişir. Fonksiyonlar çalıştırıldığında döngü çoktan bitmiştir ve <code class="language-plaintext highlighter-rouge">i</code> değişkeninin son değeri <code class="language-plaintext highlighter-rouge">2</code> olmuştur.</p>

<p>Bu davranış <strong>late binding</strong>, yani geç bağlama olarak adlandırılır. Bağlamanın fonksiyon tanımlanırken değil, fonksiyon çağrılırken gerçekleştiğini düşünebiliriz.</p>

<p>Matematiksel olarak üç fonksiyon oluşturduğumuzu varsayalım. Beklentimiz:</p>

\[f_0() = 0, \quad f_1() = 1, \quad f_2() = 2\]

<p>Fakat fonksiyonların tamamı aynı değişken hücresine başvurduğu için gerçekte:</p>

\[f_i() = i_{son} = 2\]

<p>olur.</p>

<h2 id="closure-tam-olarak-neyi-saklar">Closure tam olarak neyi saklar?</h2>

<p>Closure, dış kapsamdaki değişkenlere erişebilen iç fonksiyondur. Önemli ayrıntı şudur: Python çoğu durumda değişkenin o anki değerini değil, değişkenin bulunduğu <strong>hücreyi</strong> saklar. Hücrenin içeriği sonradan değişirse closure yeni içeriği görür.</p>

<p>Python isimleri ararken kabaca <strong>LEGB</strong> sırasını kullanır:</p>

<table>
  <thead>
    <tr>
      <th>Kapsam</th>
      <th>Anlamı</th>
      <th>Örnek</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Local</td>
      <td>Fonksiyonun yerel alanı</td>
      <td>Parametreler</td>
    </tr>
    <tr>
      <td>Enclosing</td>
      <td>Dış fonksiyonların alanı</td>
      <td>Closure değişkenleri</td>
    </tr>
    <tr>
      <td>Global</td>
      <td>Modül seviyesi</td>
      <td>Dosyada tanımlanan isimler</td>
    </tr>
    <tr>
      <td>Built-in</td>
      <td>Yerleşik isimler</td>
      <td><code class="language-plaintext highlighter-rouge">len</code>, <code class="language-plaintext highlighter-rouge">print</code></td>
    </tr>
  </tbody>
</table>

<p>Döngüdeki <code class="language-plaintext highlighter-rouge">i</code>, lambda’nın yerel parametresi değildir. Bu nedenle çağrı sırasında dış kapsamdan okunur.</p>

<h2 id="en-yaygın-çözüm-varsayılan-parametre">En yaygın çözüm: varsayılan parametre</h2>

<p>Değeri lambda oluşturulurken sabitlemek için varsayılan parametre kullanılabilir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">fonksiyonlar</span> <span class="o">=</span> <span class="p">[]</span>

<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">3</span><span class="p">):</span>
    <span class="n">fonksiyonlar</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="k">lambda</span> <span class="n">i</span><span class="o">=</span><span class="n">i</span><span class="p">:</span> <span class="n">i</span><span class="p">)</span>

<span class="k">for</span> <span class="n">fonksiyon</span> <span class="ow">in</span> <span class="n">fonksiyonlar</span><span class="p">:</span>
    <span class="nf">print</span><span class="p">(</span><span class="nf">fonksiyon</span><span class="p">())</span>
</code></pre></div></div>

<p>Bu kez çıktı <code class="language-plaintext highlighter-rouge">0, 1, 2</code> olur. Çünkü varsayılan parametre ifadeleri fonksiyon <strong>tanımlandığı anda</strong> değerlendirilir. Sağ taraftaki <code class="language-plaintext highlighter-rouge">i</code>, mevcut döngü değerini alır; sol taraftaki <code class="language-plaintext highlighter-rouge">i</code> ise lambda’nın yerel parametresidir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Bağlanma zamanı</th>
      <th>Sonuç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">lambda: i</code></td>
      <td>Çağrı anı</td>
      <td>Son değer görülür</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">lambda i=i: i</code></td>
      <td>Tanımlama anı</td>
      <td>Her değer ayrı saklanır</td>
    </tr>
  </tbody>
</table>

<h2 id="factory-fonksiyonu-kullanmak">Factory fonksiyonu kullanmak</h2>

<p>Daha karmaşık işlemlerde varsayılan parametre numarası yerine açıklayıcı bir üretici fonksiyon tercih edilebilir:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">carpani_uret</span><span class="p">(</span><span class="n">carpan</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">carp</span><span class="p">(</span><span class="n">sayi</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">sayi</span> <span class="o">*</span> <span class="n">carpan</span>
    <span class="k">return</span> <span class="n">carp</span>

<span class="n">fonksiyonlar</span> <span class="o">=</span> <span class="p">[</span><span class="nf">carpani_uret</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="nf">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)]</span>

<span class="nf">print</span><span class="p">([</span><span class="nf">fonksiyon</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="k">for</span> <span class="n">fonksiyon</span> <span class="ow">in</span> <span class="n">fonksiyonlar</span><span class="p">])</span>
<span class="c1"># [0, 10, 20]
</span></code></pre></div></div>

<p>Her <code class="language-plaintext highlighter-rouge">carpani_uret</code> çağrısı yeni bir yerel kapsam oluşturur. Böylece her iç fonksiyon farklı bir <code class="language-plaintext highlighter-rouge">carpan</code> hücresine sahip olur. Bu yaklaşım daha uzun olsa da okunabilirliği yüksektir.</p>

<p>Alternatif olarak <code class="language-plaintext highlighter-rouge">functools.partial</code>, bir fonksiyonun belirli argümanlarını önceden bağlamak için kullanılabilir:</p>

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

<span class="k">def</span> <span class="nf">carp</span><span class="p">(</span><span class="n">sayi</span><span class="p">,</span> <span class="n">carpan</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">sayi</span> <span class="o">*</span> <span class="n">carpan</span>

<span class="n">fonksiyonlar</span> <span class="o">=</span> <span class="p">[</span><span class="nf">partial</span><span class="p">(</span><span class="n">carp</span><span class="p">,</span> <span class="n">carpan</span><span class="o">=</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="nf">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)]</span>
</code></pre></div></div>

<p>Late binding özellikle buton callback’lerinde, zamanlayıcılarda, olay dinleyicilerinde ve asenkron görevlerde ortaya çıkar. Kısa kural şudur: Döngü değişkenini daha sonra çalışacak bir fonksiyonda kullanıyorsanız, değeri varsayılan parametreyle, factory fonksiyonuyla veya <code class="language-plaintext highlighter-rouge">partial</code> ile açıkça bağlayın. Böylece lambda’lar sürpriz kutusu olmaktan çıkar.</p>

<p><img src="/img/pythonda-late-binding-15.svg" alt="pythonda-late-binding-15" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="python" /><category term="lambda" /><category term="closure" /><category term="late-binding" /><category term="fonksiyonel-programlama" /><summary type="html"><![CDATA[Bir döngü içinde birkaç lambda oluşturup her birinin farklı değeri hatırlamasını beklersiniz. Ardından hepsi aynı sonucu döndürür ve Python masumca size bakar. Bu davranış bir hata değil; closure’ların değişkenleri nasıl bağladığıyla ilgili önemli bir Python kuralıdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/pythonda-late-binding-15.png" /><media:content medium="image" url="https://program.sonsuz.us/img/pythonda-late-binding-15.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Shell find: -exec ve xargs Arasında Performans ve Güvenlik Düellosu</title><link href="https://program.sonsuz.us/posts/shell-find-exec-ve-xargs-arasinda-performans-ve-guvenlik-duellosu/" rel="alternate" type="text/html" title="Shell find: -exec ve xargs Arasında Performans ve Güvenlik Düellosu" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/shell-find-exec-ve-xargs-arasinda-performans-ve-guvenlik-duellosu</id><content type="html" xml:base="https://program.sonsuz.us/posts/shell-find-exec-ve-xargs-arasinda-performans-ve-guvenlik-duellosu/"><![CDATA[<p><img src="/img/shell-find-exec-69.svg" alt="shell-find-exec-69" /></p>

<p><code class="language-plaintext highlighter-rouge">find</code> ile binlerce dosyayı aradıktan sonra üzerlerinde işlem yapmak istediğimizde iki popüler seçenek karşımıza çıkar: <code class="language-plaintext highlighter-rouge">-exec</code> ve <code class="language-plaintext highlighter-rouge">xargs</code>. İkisi de bulunan yolları başka bir komuta aktarır; ancak süreç oluşturma maliyeti, özel karakter içeren dosya adları ve güvenilmeyen dizinlerle çalışma konusunda davranışları aynı değildir. Yanlış seçim betiği yalnızca yavaşlatmaz, beklenmedik dosyaların işlenmesine de yol açabilir.</p>

<p>``</p>

<h2 id="temel-çalışma-mantığı">Temel çalışma mantığı</h2>

<p>Klasik <code class="language-plaintext highlighter-rouge">-exec</code>, bulunan her dosya için komutu ayrı çalıştırabilir:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>find logs <span class="nt">-type</span> f <span class="nt">-name</span> <span class="s1">'*.log'</span> <span class="nt">-exec</span> <span class="nb">gzip</span> <span class="s1">'{}'</span> <span class="se">\;</span>
</code></pre></div></div>

<p>Buradaki <code class="language-plaintext highlighter-rouge">{}</code> bulunan dosyanın tam yolu ile değiştirilir, <code class="language-plaintext highlighter-rouge">\;</code> ise <code class="language-plaintext highlighter-rouge">-exec</code> ifadesini sonlandırır. Dosya adı komuta doğrudan bir argüman olarak verildiğinden boşluklar, satır sonları veya joker karakterler yeniden yorumlanmaz.</p>

<p>Buna karşılık <code class="language-plaintext highlighter-rouge">xargs</code>, standart girdiden aldığı yolları gruplandırarak komut satırları oluşturur:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>find logs <span class="nt">-type</span> f <span class="nt">-name</span> <span class="s1">'*.log'</span> <span class="nt">-print0</span> |
  xargs <span class="nt">-0</span> <span class="nb">gzip</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">-print0</code> yolları NUL karakteriyle ayırır; <code class="language-plaintext highlighter-rouge">xargs -0</code> aynı biçimi okur. Unix dosya adlarında NUL bulunamayacağı için bu ikili, sıra dışı dosya adlarında güvenli bir protokol sağlar.</p>

<h2 id="performans-neden-değişiyor">Performans neden değişiyor?</h2>

<p>Bir süreç başlatmanın maliyetini $C_p$, tek bir dosyayı işlemenin maliyetini $C_f$ ve dosya sayısını $n$ kabul edelim. Dosya başına çalışan klasik kullanımın yaklaşık maliyeti:</p>

\[T_{exec} \approx n(C_p + C_f)\]

<p><code class="language-plaintext highlighter-rouge">xargs</code> dosyaları ortalama $b$ elemanlık gruplara ayırırsa maliyet yaklaşık olarak şöyledir:</p>

\[T_{xargs} \approx \left\lceil\frac{n}{b}\right\rceil C_p + nC_f\]

<p>Dolayısıyla kısa süren bir komut binlerce kez çağrıldığında süreç maliyeti belirginleşir. Fakat <code class="language-plaintext highlighter-rouge">find</code> modern ve daha güvenli bir toplu çalışma seçeneğine de sahiptir:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>find logs <span class="nt">-type</span> f <span class="nt">-name</span> <span class="s1">'*.log'</span> <span class="nt">-exec</span> <span class="nb">gzip</span> <span class="s1">'{}'</span> +
</code></pre></div></div>

<p>Sondaki <code class="language-plaintext highlighter-rouge">+</code>, mümkün olduğunca çok yolu tek komut çağrısında toplar. Böylece <code class="language-plaintext highlighter-rouge">xargs</code> benzeri performans elde edilirken ayrı bir boru hattına ihtiyaç kalmaz. Her iki yöntem de işletim sisteminin <code class="language-plaintext highlighter-rouge">ARG_MAX</code> sınırını dikkate alarak grupları böler.</p>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th style="text-align: right">Komut çağrısı</th>
      <th>Dosya adı güvenliği</th>
      <th>Paralellik</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">-exec ... \;</code></td>
      <td style="text-align: right">Her dosya için bir</td>
      <td>Yüksek</td>
      <td>Doğrudan yok</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">-exec ... +</code></td>
      <td style="text-align: right">Toplu</td>
      <td>Yüksek</td>
      <td>Doğrudan yok</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">xargs</code></td>
      <td style="text-align: right">Toplu</td>
      <td>Ayırıcılara bağlı</td>
      <td><code class="language-plaintext highlighter-rouge">-P</code> ile var</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">-print0 \| xargs -0</code></td>
      <td style="text-align: right">Toplu</td>
      <td>Yüksek</td>
      <td><code class="language-plaintext highlighter-rouge">-P</code> ile var</td>
    </tr>
  </tbody>
</table>

<h2 id="güvenlikte-asıl-tuzaklar">Güvenlikte asıl tuzaklar</h2>

<p>Şu kullanım güvenilir değildir:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>find uploads <span class="nt">-type</span> f | xargs <span class="nb">rm</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">rapor final.txt</code> iki ayrı argümana bölünebilir. Daha kötüsü, dosya adında satır sonu veya tırnak bulunması ayrıştırmayı bozabilir. Çözüm <code class="language-plaintext highlighter-rouge">-print0 | xargs -0</code> kullanmak ya da doğrudan <code class="language-plaintext highlighter-rouge">-exec ... +</code> seçmektir.</p>

<p><code class="language-plaintext highlighter-rouge">xargs</code> kendi başına bir shell başlatmaz; bu nedenle dosya adındaki <code class="language-plaintext highlighter-rouge">;</code> veya <code class="language-plaintext highlighter-rouge">$()</code> otomatik olarak çalıştırılmaz. Tehlike genellikle girdiyi metin olarak ayrıştırmaktan veya gereksiz yere <code class="language-plaintext highlighter-rouge">sh -c</code> kullanmaktan doğar:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Güvenilmeyen adları komut metnine gömmeyin</span>
find uploads <span class="nt">-type</span> f <span class="nt">-exec</span> sh <span class="nt">-c</span> <span class="s2">"process {}"</span> <span class="se">\;</span>
</code></pre></div></div>

<p>Bunun yerine yolu konumsal argüman yapın:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>find uploads <span class="nt">-type</span> f <span class="nt">-exec</span> sh <span class="nt">-c</span> <span class="s1">'for f; do process "$f"; done'</span> sh <span class="s1">'{}'</span> +
</code></pre></div></div>

<p>Ayrıca bulunan dosya ile işlemin uygulanması arasında dosyanın değiştirilebildiği yarış koşulları her iki yöntemi de etkileyebilir. Güvenilmeyen, başkalarının yazabildiği dizinlerde <code class="language-plaintext highlighter-rouge">-execdir</code> komutu dosyanın bulunduğu dizinde çalıştırarak bazı yol değiştirme saldırılarını azaltır. Bununla birlikte güvenli bir <code class="language-plaintext highlighter-rouge">PATH</code> ayarlamak gerekir.</p>

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

<p>Genel amaçlı ve sağlam varsayılan seçenek <code class="language-plaintext highlighter-rouge">-exec ... +</code> kullanmaktır: hızlıdır, okunaklıdır ve dosya adlarını doğru taşır. Paralel işlem gerekiyorsa <code class="language-plaintext highlighter-rouge">-print0 | xargs -0 -P 4</code> güçlüdür; ancak komutun eş zamanlı çalışmaya uygun olduğundan emin olun. Her dosyanın ayrı süreçte çalışması özellikle gerekmiyorsa <code class="language-plaintext highlighter-rouge">-exec ... \;</code> büyük veri kümelerinde gereksiz derecede pahalıdır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="shell" /><category term="linux" /><category term="find" /><category term="xargs" /><category term="performans" /><category term="güvenlik" /><summary type="html"><![CDATA[find ile binlerce dosyayı aradıktan sonra üzerlerinde işlem yapmak istediğimizde iki popüler seçenek karşımıza çıkar: -exec ve xargs. İkisi de bulunan yolları başka bir komuta aktarır; ancak süreç oluşturma maliyeti, özel karakter içeren dosya adları ve güvenilmeyen dizinlerle çalışma konusunda davranışları aynı değildir. Yanlış seçim betiği yalnızca yavaşlatmaz, beklenmedik dosyaların işlenmesine de yol açabilir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/shell-find-exec-69.png" /><media:content medium="image" url="https://program.sonsuz.us/img/shell-find-exec-69.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Teleoperasyonda Görünmez Engel: Zaman Gecikmesi Operatör Performansını Nasıl Etkiler?</title><link href="https://program.sonsuz.us/posts/teleoperasyonda-gorunmez-engel-zaman-gecikmesi-operator-performansini-nasil-etkiler/" rel="alternate" type="text/html" title="Teleoperasyonda Görünmez Engel: Zaman Gecikmesi Operatör Performansını Nasıl Etkiler?" /><published>2026-10-19T00:00:00+00:00</published><updated>2026-10-19T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/teleoperasyonda-gorunmez-engel-zaman-gecikmesi-operator-performansini-nasil-etkiler</id><content type="html" xml:base="https://program.sonsuz.us/posts/teleoperasyonda-gorunmez-engel-zaman-gecikmesi-operator-performansini-nasil-etkiler/"><![CDATA[<p><img src="/img/teleoperasyonda-gorunmez-engel-89.svg" alt="teleoperasyonda-gorunmez-engel-89" /></p>

<p>Bir robotu kilometrelerce uzaktan yönetmek, ekrandaki görüntüye bakarak oyun oynamaya benzeyebilir. Ancak komut ile hareket arasındaki gecikme büyüdüğünde oyun kumandası hissi kaybolur; robot adeta geçmişten gelen talimatlarla hareket etmeye başlar. Özellikle cerrahi, afet müdahalesi, uzay araştırmaları ve tehlikeli madde operasyonlarında birkaç yüz milisaniyelik gecikme bile operatörün hızını, doğruluğunu ve güvenini ciddi biçimde etkileyebilir.
``</p>

<h2 id="zaman-gecikmesi-tam-olarak-nedir">Zaman gecikmesi tam olarak nedir?</h2>

<p>Teleoperasyonda <strong>latency</strong>, operatörün verdiği komutun robota ulaşması ve robotun durum bilgisinin operatöre geri dönmesi sırasında geçen süredir. Tek yönlü gecikme $T_d$ ile gösterilirse yaklaşık çevrim süresi, yani <em>round-trip time</em> şu şekilde ifade edilir:</p>

\[T_{RTT} = T_{ileri} + T_{işleme} + T_{geri}\]

<p>Burada ağ aktarımı dışında kamera kodlama, sensör işleme, kontrolcü hesaplaması ve ekran yenileme süresi de bulunur. Dolayısıyla hızlı internet tek başına sıfır gecikme anlamına gelmez.</p>

<p>Gecikmeli bir sistemin basitleştirilmiş çıktısı ise şöyle düşünülebilir:</p>

\[y(t) = G\big(u(t-T_d)\big)\]

<p>Operatör şu anda $u(t)$ komutunu verse bile robot, gerçekte daha önce üretilmiş $u(t-T_d)$ komutuna tepki verir. İnsan beyni anlık geri bildirim beklediği için bu fark arttıkça kontrol zorlaşır.</p>

<h2 id="operatör-performansı-nasıl-değişir">Operatör performansı nasıl değişir?</h2>

<table>
  <thead>
    <tr>
      <th>Gecikme düzeyi</th>
      <th>Operatör deneyimi</th>
      <th>Muhtemel sonuç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0–100 ms</td>
      <td>Doğala yakın kontrol</td>
      <td>Hızlı ve hassas hareket</td>
    </tr>
    <tr>
      <td>100–300 ms</td>
      <td>Hafif kopukluk hissi</td>
      <td>Küçük düzeltme hataları</td>
    </tr>
    <tr>
      <td>300–700 ms</td>
      <td>Belirgin bekleme</td>
      <td>Aşırı düzeltme ve yavaşlama</td>
    </tr>
    <tr>
      <td>700 ms üzeri</td>
      <td>Komut-sonuç bağı zayıflar</td>
      <td>Çarpışma, salınım ve görev kaybı</td>
    </tr>
  </tbody>
</table>

<p>Bu sınırlar göreve göre değişir. Açık arazide ilerleyen yavaş bir keşif robotu 500 ms gecikmeyi tolere edebilirken, robotik bir kol ile kırılgan nesne kavramak için aynı değer oldukça risklidir.</p>

<p>En yaygın problem <strong>aşırı düzeltmedir</strong>. Operatör robotun dönmediğini görüp ikinci bir dönüş komutu verir. Oysa ilk komut hâlâ ağdadır. İki komut arka arkaya uygulanınca robot hedefi geçer; operatör bu kez ters yöne müdahale eder ve sistem zikzak çizmeye başlar. Gecikme değişkense, yani <em>jitter</em> varsa, operatör sabit bir ritme bile uyum sağlayamaz.</p>

<h2 id="basit-bir-gecikme-simülasyonu">Basit bir gecikme simülasyonu</h2>

<p>Aşağıdaki Python örneği, komutları bir kuyrukta tutarak sabit gecikmenin etkisini gösterir:</p>

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

<span class="n">latency_steps</span> <span class="o">=</span> <span class="mi">4</span>
<span class="n">command_buffer</span> <span class="o">=</span> <span class="nf">deque</span><span class="p">([</span><span class="mf">0.0</span><span class="p">]</span> <span class="o">*</span> <span class="n">latency_steps</span><span class="p">)</span>
<span class="n">robot_position</span> <span class="o">=</span> <span class="mf">0.0</span>

<span class="n">commands</span> <span class="o">=</span> <span class="p">[</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.0</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">]</span>

<span class="k">for</span> <span class="n">command</span> <span class="ow">in</span> <span class="n">commands</span><span class="p">:</span>
    <span class="n">command_buffer</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="n">command</span><span class="p">)</span>
    <span class="n">applied_command</span> <span class="o">=</span> <span class="n">command_buffer</span><span class="p">.</span><span class="nf">popleft</span><span class="p">()</span>
    <span class="n">robot_position</span> <span class="o">+=</span> <span class="n">applied_command</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">'</span><span class="s">Gönderilen: </span><span class="si">{</span><span class="n">command</span><span class="si">:</span><span class="o">+</span><span class="p">.</span><span class="mi">1</span><span class="n">f</span><span class="si">}</span><span class="s">, uygulanan: </span><span class="si">{</span><span class="n">applied_command</span><span class="si">:</span><span class="o">+</span><span class="p">.</span><span class="mi">1</span><span class="n">f</span><span class="si">}</span><span class="s">, konum: </span><span class="si">{</span><span class="n">robot_position</span><span class="si">:</span><span class="o">+</span><span class="p">.</span><span class="mi">1</span><span class="n">f</span><span class="si">}</span><span class="sh">'</span><span class="p">)</span>
</code></pre></div></div>

<p>Kodda operatörün yeni komutu hemen uygulanmaz; dört adım sonra robot üzerinde etkili olur. Gerçek sistemlerde bu tampon ağ, görüntü ve kontrol gecikmelerinin toplamını temsil eder.</p>

<h2 id="etkiyi-azaltma-yöntemleri">Etkiyi azaltma yöntemleri</h2>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Avantaj</th>
      <th>Sınırlama</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Hareket tahmini</td>
      <td>Gelecekteki konumu gösterir</td>
      <td>Model hatası oluşabilir</td>
    </tr>
    <tr>
      <td>Yerel otonomi</td>
      <td>Engelleri robot önler</td>
      <td>Operatör kontrolü azalabilir</td>
    </tr>
    <tr>
      <td>Komut filtreleme</td>
      <td>Ani salınımları bastırır</td>
      <td>Tepkiyi yavaşlatabilir</td>
    </tr>
    <tr>
      <td>Uyarlanabilir arayüz</td>
      <td>Gecikmeyi görünür kılar</td>
      <td>Eğitim gerektirir</td>
    </tr>
  </tbody>
</table>

<p>En başarılı yaklaşım genellikle insan ile otonomiyi yarıştırmak değil, görev paylaşımı yaptırmaktır. Operatör hedefi belirlerken robot yerel çarpışma önleme ve denge kontrolünü üstlenebilir. Ayrıca tahmini robot gölgesi, gecikme göstergesi ve haptik uyarılar operatörün zihinsel yükünü azaltır.</p>

<p>Sonuç olarak latency yalnızca teknik bir ağ metriği değildir; doğrudan insan performansını şekillendiren bir kontrol problemidir. Güvenli teleoperasyon tasarımı, gecikmeyi azaltmanın yanında onu ölçmeli, operatöre göstermeli ve robotun davranışını gecikmeye dayanıklı hâle getirmelidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="robotik" /><category term="teleoperasyon" /><category term="latency" /><category term="kontrol-sistemleri" /><category term="insan-robot-etkileşimi" /><summary type="html"><![CDATA[Bir robotu kilometrelerce uzaktan yönetmek, ekrandaki görüntüye bakarak oyun oynamaya benzeyebilir. Ancak komut ile hareket arasındaki gecikme büyüdüğünde oyun kumandası hissi kaybolur; robot adeta geçmişten gelen talimatlarla hareket etmeye başlar. Özellikle cerrahi, afet müdahalesi, uzay araştırmaları ve tehlikeli madde operasyonlarında birkaç yüz milisaniyelik gecikme bile operatörün hızını, doğruluğunu ve güvenini ciddi biçimde etkileyebilir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/teleoperasyonda-gorunmez-engel-89.png" /><media:content medium="image" url="https://program.sonsuz.us/img/teleoperasyonda-gorunmez-engel-89.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>