``

rm -rf gerçekte ne yapar?

rm, dosya ve dizinleri kaldırır. -r seçeneği dizinlerin içine özyinelemeli olarak girilmesini, -f ise uyarıların bastırılıp işlemin zorlanmasını sağlar. Başka bir deyişle komutun mantığı kabaca şöyledir:

Kök kullanıcı yetkisiyle geniş bir hedef seçildiğinde üç çarpan da büyür. Sonuç, geri dönüşüm kutusuna taşınan dosyalar değil; dosya sistemi kayıtlarının doğrudan kaldırılmasıdır.

Burada önemli bir düzeltme var: rm -rf / ile rm -rf /* arasındaki fark yalnızca boşluk değildir; yıldız karakteri kabuk tarafından genişletilir. Modern GNU rm, / hedefini genellikle --preserve-root korumasıyla reddeder. Ancak /*, kabuk tarafından /etc, /home, /usr gibi ayrı hedeflere dönüştürülebildiğinden bu korumayı aşabilir. Yani iki komut da güvenli değildir.

Boşluk hatası nasıl felakete dönüşür?

Shell, boşluğu argüman ayırıcı olarak kullanır. Örneğin amaç /tmp/proje içeriğini silmekken yanlışlıkla yolun ortasına boşluk eklenirse komut iki farklı hedef algılayabilir. Benzer şekilde boş bir değişken de beklenmeyen bir hedef meydana getirir:

# TEHLİKELİ ÖRNEK: Değişken boşsa hedef beklenenden farklılaşabilir.
rm -rf "$TARGET"/*

TARGET boş olduğunda ifade /* biçimine yaklaşır. Bu nedenle değişken kullanmadan önce hem doluluk hem de izin verilen kök yol denetlenmelidir.

Daha güvenli bir silme deseni

Aşağıdaki yaklaşım hedefi doğrular, mutlak yola dönüştürür ve yalnızca belirlenmiş çalışma alanı içindeki dizinlere izin verir:

#!/usr/bin/env bash
set -euo pipefail

target="${1:-}"
allowed_root="/srv/builds"

if [[ -z "$target" ]]; then
  echo "Hata: Hedef boş olamaz." >&2
  exit 1
fi

resolved="$(realpath -- "$target")"

if [[ "$resolved" != "$allowed_root"/* ]]; then
  echo "Hata: İzin verilen alanın dışında: $resolved" >&2
  exit 1
fi

printf 'Silinecek hedef: %s\n' "$resolved"
rm -rf -- "$resolved"

set -u, tanımsız değişkenleri hata kabul eder. realpath, .. ve sembolik bağlantı kaynaklı belirsizlikleri azaltır. -- ise tireyle başlayan bir dosya adının seçenek sanılmasını engeller. Yine de bu kod, yedeklemenin yerini tutmaz.

Kazayı önlemek için pratik kurallar

1. Komutu çalıştırmadan önce hedefi printf '%q\n' "$target" ile görüntüleyin.
2. Önce ls veya find kullanarak kapsamı inceleyin.
3. Betiklerde set -euo pipefail etkinleştirin.
4. Kritik işlemleri root yerine sınırlı yetkili kullanıcıyla yürütün.
5. Snapshot ve çevrimdışı yedek bulundurun; aynı diskteki kopya gerçek yedek değildir.
6. Etkileşimli kullanımda rm -I seçeneğini değerlendirin.

Yanlış silme gerçekleşirse sistemi hemen kullanmayı bırakmak, diske yeni veri yazmamak ve profesyonel kurtarma araçlarına yönelmek gerekir. En iyi kurtarma stratejisi ise hâlâ kazadan önce hazırlanmış, düzenli olarak test edilen bir yedektir.

``

Önce problem: Sil, sonra kopyala

Dinamik dizi yöneten basit bir sınıf düşünelim. Tehlikeli bir atama operatörü eski belleği önce silebilir, ardından yeni bellek ayırmaya çalışabilir:

Buffer& operator=(const Buffer& other) {
    delete[] data_;
    size_ = other.size_;
    data_ = new int[size_]; // std::bad_alloc fırlatabilir
    std::copy(other.data_, other.data_ + size_, data_);
    return *this;
}

new başarısız olduğunda eski veri çoktan kaybedilmiştir. Üstelik data_, silinmiş belleği gösterebilir. Nesne artık yalnızca yanlış değil, yıkıcısı çalıştığında ikinci kez silme yapabilecek kadar tehlikelidir.

İstisna güvenliği genellikle üç seviyede değerlendirilir:

Güçlü garantiyi matematiksel olarak bir durum geçişi gibi ifade edebiliriz. Eski durum $S$, hedef durum $T$ ise:

Yani yarım kalmış, garip bir $S’$ durumuna izin verilmez.

Copy-and-swap nasıl çalışır?

Teknik üç adımdan oluşur:

1. Sağ taraftaki nesnenin geçici bir kopyasını oluştur.
2. Geçici nesne ile mevcut nesnenin kaynaklarını değiştir.
3. Geçici nesne kapsam dışına çıkınca eski kaynakları otomatik olarak yok etsin.

#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
public:
    explicit Buffer(std::size_t size = 0)
        : size_(size), data_(size ? new int[size]{} : nullptr) {}

    Buffer(const Buffer& other)
        : size_(other.size_),
          data_(size_ ? new int[size_] : nullptr) {
        std::copy(other.data_, other.data_ + size_, data_);
    }

    Buffer(Buffer&& other) noexcept
        : size_(std::exchange(other.size_, 0)),
          data_(std::exchange(other.data_, nullptr)) {}

    ~Buffer() {
        delete[] data_;
    }

    friend void swap(Buffer& a, Buffer& b) noexcept {
        using std::swap;
        swap(a.size_, b.size_);
        swap(a.data_, b.data_);
    }

    Buffer& operator=(Buffer other) {
        swap(*this, other);
        return *this;
    }

private:
    std::size_t size_{};
    int* data_{};
};

Buradaki kritik ayrıntı, parametrenin const Buffer& yerine değerle alınmasıdır. Bir lvalue gönderildiğinde kopya kurucu, rvalue gönderildiğinde ise taşıma kurucu geçici other nesnesini hazırlar. Böylece tek operatör hem kopyalama hem taşıma atamasını karşılayabilir.

Kopyalama sırasında new istisna fırlatırsa fonksiyon gövdesine henüz girilmez; *this değişmeden kalır. Kopya başarıyla oluşursa swap yalnızca boyut ve işaretçi gibi ucuz üyeleri değiştirir. Bu nedenle swap fonksiyonunun noexcept olması güçlü garantinin merkezidir. Değişimden sonra other, hedef nesnenin eski belleğini taşır ve yıkıcısı bu belleği temizler. RAII burada temizlik ekibidir; hem de fazla mesai ücreti istemez.

Geleneksel atama ile karşılaştırma

Copy-and-swap temiz ve güvenlidir; ancak her zaman en hızlı çözüm değildir. Büyük tamponlarda mevcut kapasiteyi yeniden kullanmak önemliyse özel bir atama operatörü daha verimli olabilir. Ayrıca sınıf yalnızca std::vector, std::string ve akıllı işaretçiler gibi RAII türlerinden oluşuyorsa en iyi seçenek çoğu zaman Rule of Zero, yani özel atama operatörü yazmamaktır.

Özetle copy-and-swap, işlemi önce hazırla, sonra tek ve güvenli adımla yayımla yaklaşımıdır. swap gerçekten noexcept olduğu sürece atama işlemini bir veritabanı işlemi gibi davranmaya yaklaştırır: ya commit gerçekleşir ya da nesne eski hâlinde kalır.

``

Dizilerin temel mantığı

Dizi, aynı türden belirli sayıda elemanı ardışık indekslerle saklayan veri yapısıdır. İndeksler sıfırdan başladığı için uzunluğu $n$ olan bir dizinin geçerli indeks aralığı $0 \le i < n$ şeklindedir. Bir elemana indeksle erişmenin zaman karmaşıklığı sabittir:

Buna karşılık aranan değerin konumu bilinmiyorsa tüm elemanların gezilmesi gerekebilir ve doğrusal aramanın maliyeti $O(n)$ olur.

int[] notlar = { 75, 90, 68, 100 };
int toplam = 0;

foreach (int not in notlar)
{
    toplam += not;
}

double ortalama = (double)toplam / notlar.Length;
Console.WriteLine($"Ortalama: {ortalama:F2}");

Bu örnek tek boyutlu diziyi dolaşır. Tür dönüşümü yapılmasaydı iki int değerin bölümü tam sayı üretirdi; (double) dönüşümü küsuratı korur.

Çok boyutlu ve düzensiz diziler

Çok boyutlu diziler satır ve sütunları eşit olan dikdörtgen tabloları temsil eder. Düzensiz, yani jagged diziler ise her satırında farklı sayıda eleman taşıyabilen dizilerin dizisidir.

int[,] harita =
{
    { 1, 0, 1 },
    { 0, 1, 0 }
};

int[][] gruplar =
{
    new[] { 10, 20 },
    new[] { 30, 40, 50 },
    new[] { 60 }
};

Console.WriteLine(harita[1, 1]); // 1
Console.WriteLine(gruplar[1][2]); // 50

int[,] tek bir dikdörtgen bloktur. int[][] içindeki her satır ise bağımsız bir dizidir. Bu esneklik bellek kullanımını azaltabilir; ancak satırların ayrı ayrı oluşturulması ve kontrol edilmesi gerekir.

String: Karakter dizisinden daha fazlası

string, kavramsal olarak karakter dizisine benzese de immutable, yani değiştirilemez bir referans türüdür. Birleştirme veya değiştirme işlemi mevcut metni düzenlemez; yeni bir string üretir.

string mesaj = "  C# diziler eğlencelidir  ";
string temiz = mesaj.Trim();
string[] kelimeler = temiz.Split(' ', StringSplitOptions.RemoveEmptyEntries);
string sonuc = string.Join(" | ", kelimeler).ToUpperInvariant();

Console.WriteLine(sonuc);

Burada Trim kenar boşluklarını kaldırır, Split metni parçalara ayırır, Join parçaları yeniden birleştirir. ToUpperInvariant, sonucu kullanıcının bölgesel dil ayarlarından bağımsız biçimde büyük harfe dönüştürür.

Çok sayıda birleştirmede StringBuilder

Döngü içinde + kullanmak çok sayıda geçici nesne oluşturabilir. Bu durumda StringBuilder, değiştirilebilir bir karakter tamponu sunar:

using System.Text;

var rapor = new StringBuilder();
foreach (int not in notlar)
{
    rapor.Append("Not: ").AppendLine(not.ToString());
}

Console.WriteLine(rapor.ToString());

Az sayıdaki birleştirmede string interpolation okunaklıdır; yoğun işlemlerde ise StringBuilder daha verimlidir. Özetle doğru dizi türünü veri şekline, doğru metin aracını da işlem yoğunluğuna göre seçmek hem performansı hem kod okunabilirliğini artırır.

Bir projede yalnızca birkaç değişken ve sınıf varken isim bulmak kolaydır. Ancak kod tabanı büyüdükçe farklı geliştiricilerin aynı Logger, Config veya User adını kullanması kaçınılmaz hâle gelir. C++ isim alanları, yani namespace yapıları, bu isimleri mantıksal gruplara ayırarak derleyiciye hangi varlığı kastettiğimizi söyler. Kısacası namespace, kod dünyasının mahalle adresidir: Aynı isimli iki kişi olabilir, yeter ki farklı adreslerde yaşasın!

``

İsim çakışması neden oluşur?

C++ dilinde bir ismin hangi bölgeden erişilebilir olduğunu belirleyen kurallara kapsam, yani scope denir. Global kapsamda tanımlanan isimler projenin birçok noktasından görülebildiği için çakışma olasılığı yükselir. Bir projede birbirinden bağımsız $n$ bileşen ve her bileşende ortalama $k$ genel isim bulunduğunu düşünelim. Karşılaştırılabilecek isim çiftlerinin sayısı yaklaşık olarak şöyledir:

Bu ifade doğrudan kesin çakışma sayısını vermez; proje büyüdükçe riskin neden hızla arttığını gösterir. İsimleri namespace gruplarına bölmek, karşılaştırma alanını küçültür.

Temel namespace kullanımı

Bir isim alanı namespace anahtar sözcüğüyle tanımlanır. Aynı sınıf adı farklı alanlarda güvenle bulunabilir:

#include <iostream>
#include <string>

namespace Database {
    class Connection {
    public:
        void open() const {
            std::cout << "Veritabanı bağlantısı açıldı.\n";
        }
    };
}

namespace Network {
    class Connection {
    public:
        void open() const {
            std::cout << "Ağ bağlantısı açıldı.\n";
        }
    };
}

int main() {
    Database::Connection database;
    Network::Connection network;

    database.open();
    network.open();
}

Buradaki :: operatörüne kapsam çözümleme operatörü denir. Database::Connection, derleyiciye yalnızca Connection sınıfını değil, sınıfın tam adresini verir.

using kullanırken dikkat

Uzun isimleri sürekli yazmamak için using bildirimi kullanılabilir:

using Database::Connection;

int main() {
    Connection connection;
    connection.open();
}

Bu yöntem yalnızca ihtiyaç duyulan ismi mevcut kapsama taşır. Buna karşılık aşağıdaki kullanım özellikle başlık dosyalarında risklidir:

using namespace std;

Bu ifade std içindeki çok sayıda ismi görünür yapar. Projede başka bir count, distance veya begin tanımı varsa belirsizlik oluşabilir.

İç içe ve anonim namespace

Modern C++ ile iç içe isim alanları daha kısa yazılabilir:

namespace company::project::logging {
    void write(const std::string& message) {
        std::cout << message << '\n';
    }
}

Fonksiyonun tam adı company::project::logging::write olur. Bu yapı şirket, ürün ve modül katmanlarını ifade etmek için kullanışlıdır.

Anonim namespace ise bir kaynak dosyasındaki isimleri yalnızca o çeviri birimine özel tutar:

namespace {
    int calculateSecretValue() {
        return 42;
    }
}

Bu fonksiyona başka bir .cpp dosyasından erişilemez. Böylece uygulama içi yardımcı fonksiyonlar dış dünyaya sızmaz.

Pratik kurallar

• Namespace adlarını modül sınırlarına göre seçin.
• Başlık dosyalarında using namespace kullanmayın.
• Çok genel Utils veya Common adları yerine anlamlı alanlar oluşturun.
• Genel API’lerde kısa ama ayırt edici isimler tercih edin.
• Aynı namespace’i birden fazla dosyada genişletebileceğinizi unutmayın.

Doğru namespace tasarımı yalnızca derleyici hatalarını önlemez; kodun sahibini, amacını ve mimari konumunu da anlatır. Büyük bir C++ projesinde düzen, iyi seçilmiş isimlerle; güvenlik ise o isimlere doğru adresleri vermekle başlar.

Kalıtım, bir sınıfın başka bir sınıftaki veri ve davranışları devralmasını sağlayan nesne yönelimli programlama tekniğidir. C# tarafında bu mekanizma yalnızca kod tekrarını azaltmaz; doğru kullanıldığında değiştirilebilir, genişletilebilir ve test edilebilir sistemlerin temelini oluşturur. Ancak virtual, override ve new anahtar sözcükleri karıştırılırsa masum görünen bir sınıf hiyerarşisi küçük bir sürpriz fabrikasına dönüşebilir. ``

Kalıtımın temel mantığı

Türetilmiş sınıf, temel sınıfın erişilebilir üyelerini devralır. C# dilinde sınıf türetmek için sınıf adından sonra : kullanılır:

public class Hayvan
{
    public string Ad { get; set; } = string.Empty;

    public void Beslen()
    {
        Console.WriteLine($"{Ad} besleniyor.");
    }
}

public class Kedi : Hayvan
{
    public void Mirla()
    {
        Console.WriteLine($"{Ad} mırlıyor.");
    }
}

Kedi, kendi Mirla metoduna ek olarak Hayvan sınıfındaki Ad ve Beslen üyelerini kullanabilir. Buradaki ilişki “Kedi bir Hayvan’dır” şeklinde okunur. Bu is-a ilişkisi mantıklı değilse kalıtım yerine bileşim tercih edilmelidir.

Bir hiyerarşideki sınıf sayısını $n$, her sınıfta tekrarlanacak ortak davranış miktarını $m$ kabul edersek kaba tekrar maliyeti $n \times m$ olur. Ortak davranışı temel sınıfa taşımak bu miktarı yaklaşık $m + n$ seviyesine indirebilir. Elbette gerçek tasarım kalitesi yalnızca satır sayısıyla ölçülmez.

Sanal metot ve ezme işlemi

Temel sınıf, alt sınıfların bir davranışı değiştirmesine izin vermek için metodu virtual olarak tanımlar. Türetilmiş sınıf ise override ile aynı sözleşmenin yeni uygulamasını sunar:

public class Hayvan
{
    public virtual void SesCikar()
    {
        Console.WriteLine("Bilinmeyen hayvan sesi");
    }
}

public class Kedi : Hayvan
{
    public override void SesCikar()
    {
        Console.WriteLine("Miyav!");
    }
}

Hayvan dost = new Kedi();
dost.SesCikar(); // Miyav!

Değişkenin derleme zamanı türü Hayvan, gerçek nesnenin türü ise Kedi olmasına rağmen Kedi.SesCikar çalışır. Buna çalışma zamanı polimorfizmi denir. Hangi uygulamanın seçileceği nesnenin gerçek türüne göre belirlenir.

override ile new arasındaki kritik fark

new, temel sınıftaki üyeyi ezmez; onu gizler. Bu nedenle çağrılacak metot, referansın derleme zamanı türüne bağlıdır.

public class Temel
{
    public void Yaz() => Console.WriteLine("Temel");
}

public class Turemis : Temel
{
    public new void Yaz() => Console.WriteLine("Türetilmiş");
}

Turemis a = new Turemis();
Temel b = a;

a.Yaz(); // Türetilmiş
b.Yaz(); // Temel

base, abstract ve sealed

Ezilen metot içinde temel davranışı korumak için base kullanılabilir:

public override void SesCikar()
{
    base.SesCikar();
    Console.WriteLine("Ardından özel kedi sesi: Miyav!");
}

Bir davranışın mutlaka alt sınıflarca uygulanması gerekiyorsa abstract daha güçlü bir sözleşme kurar. Daha fazla ezilmesini engellemek içinse metoda sealed override yazılabilir.

public abstract class Odeme
{
    public abstract bool Gerceklestir(decimal tutar);
}

public class KartlaOdeme : Odeme
{
    public sealed override bool Gerceklestir(decimal tutar)
    {
        return tutar > 0;
    }
}

İyi bir polimorfik tasarımda kullanıcı kodu somut sınıflara değil, temel sınıf veya arayüz sözleşmesine bağımlı olur. Alt türler temel türün yerine geçtiğinde programın anlamı bozulmamalıdır; bu yaklaşım Liskov Yerine Geçme İlkesi’nin özüdür. Kısacası davranış gerçekten çeşitlenecekse virtual/override, zorunlu uygulanacaksa abstract, yalnızca isim çakışması bilinçli biçimde yönetilecekse new kullanılmalıdır.

C# çoğunlukla güvenli ve yönetilen bir dünyada çalışır: Belleği çöp toplayıcı düzenler, dizilerin sınırları denetlenir ve geliştirici adres hesaplarıyla uğraşmaz. Ancak görüntü işleme, oyun motorları, yerel kütüphane entegrasyonu veya çok düşük gecikmeli sistemler söz konusu olduğunda bu konforun küçük bir performans maliyeti olabilir. unsafe kod, C# geliştiricisine C++ benzeri işaretçilerle belleğe doğrudan erişim imkânı verir. Güçlüdür; fakat emniyet kemerini çıkarmaya benzediği için dikkatli kullanılmalıdır.

``

Yönetilen bellekten işaretçilere

Normal C# referansı bir nesneyi gösterir, ancak nesnenin fiziksel adresini geliştiriciye açmaz. İşaretçi ise bellekteki adresi doğrudan tutar. int* ifadesi, bir int değerinin adresini taşıyan işaretçi anlamına gelir.

Bir işaretçinin kaba bellek modeli şöyle ifade edilebilir:

Örneğin int 4 baytsa p + 3, başlangıçtan yaklaşık $3 \times 4 = 12$ bayt ilerideki elemana ulaşır. İşaretçi aritmetiği bayt yerine hedef türün boyutunu hesaba kattığından kullanışlıdır.

Unsafe kodu etkinleştirme

Önce proje dosyasına aşağıdaki ayar eklenir:

<PropertyGroup>
  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>

Visual Studio kullanılıyorsa aynı seçenek proje özelliklerindeki Build > Allow code that uses the unsafe keyword alanından etkinleştirilebilir. Ardından yalnızca gerekli metot veya blok unsafe olarak işaretlenmelidir; tüm sınıfı tehlike bölgesine çevirmek şart değildir.

unsafe static void DegeriDegistir()
{
    int sayi = 10;
    int* adres = &sayi;

    *adres = 42;
    Console.WriteLine(sayi);
}

Burada &sayi, değişkenin adresini alır. *adres ise o adresteki değere erişir; buna dereference işlemi denir. Sonuç 42 olur. Yanlış veya artık geçerli olmayan bir adres kullanılırsa çalışma zamanı her zaman sizi kurtaramaz.

GC hareketine karşı fixed

Çöp toplayıcı, belleği sıkıştırırken yönetilen nesnelerin yerini değiştirebilir. Bir dizi işaretçiyle işlenirken taşınırsa işaretçi eski adresi göstermeye devam eder. fixed, nesneyi blok süresince yerine sabitler:

unsafe static int Topla(int[] sayilar)
{
    int toplam = 0;

    fixed (int* baslangic = sayilar)
    {
        for (int i = 0; i < sayilar.Length; i++)
            toplam += *(baslangic + i);
    }

    return toplam;
}

Bu kod dizinin başlangıç adresini alır ve işaretçi aritmetiğiyle elemanları gezer. fixed blokları kısa tutulmalıdır; uzun süre sabitlenen nesneler çöp toplayıcının belleği verimli düzenlemesini zorlaştırabilir.

stackalloc ve modern alternatifler

Küçük, geçici tamponlar yığında oluşturulabilir:

unsafe static int KarelerToplami(int adet)
{
    int* tampon = stackalloc int[adet];
    int toplam = 0;

    for (int i = 0; i < adet; i++)
    {
        tampon[i] = i * i;
        toplam += tampon[i];
    }

    return toplam;
}

stackalloc, çöp toplayıcıya yük bindirmez; ancak yığın kapasitesi sınırlıdır. Büyük veya kullanıcı tarafından kontrol edilen boyutlar yığın taşmasına yol açabilir. Ayrıca pek çok senaryoda Span<T> aynı performans hedefini daha güvenli sınır kontrolleriyle karşılar.

Unsafe kod otomatik olarak daha hızlı değildir. JIT derleyicisi güvenli kodu zaten güçlü biçimde optimize eder. Önce BenchmarkDotNet gibi araçlarla ölçüm yapılmalı, darboğaz kanıtlanmalı ve yalnızca kritik bölüm unsafe hâle getirilmelidir. Kural basit: Ölçmeden işaretçiye sarılmayın; kullandığınızda adresleri, sınırları ve nesne ömürlerini titizlikle yönetin.

``

Haptik geri bildirim nasıl çalışır?

Haptik cerrahi sistem, temelde çift yönlü bir iletişim döngüsüdür. Cerrah ana kontrol kollarını hareket ettirir; robot bu komutları hastanın yanındaki aletlere iletir. Alet uçlarındaki kuvvet ve tork sensörleri dokuyla etkileşimi ölçer. Ölçülen veriler, motorlar aracılığıyla kontrol kollarında direnç veya titreşim olarak yeniden üretilir.

Bu süreç üç temel bileşene dayanır:

1. Algılama: Kuvvet, basınç, titreşim ve doku deformasyonu ölçülür.
2. İletim: Veriler düşük gecikmeyle kontrol konsoluna taşınır.
3. Yeniden üretim: Cerrahın eline kontrollü bir mekanik tepki uygulanır.

İdeal durumda cerrah, sert bir tümör dokusuyla yumuşak çevre dokusu arasındaki farkı yalnızca görüntüden değil, elindeki dirençten de anlayabilir. Sistem adeta robot koluna görünmez sinir uçları ekler.

Kuvvet ölçekleme ve hareket filtreleme

Robotun hissettiği kuvvetin cerraha bire bir aktarılması her zaman güvenli değildir. Bunun yerine kuvvet ölçekleme uygulanır:

Burada $F_{doku}$ robot ucunun ölçtüğü kuvveti, $F_{el}$ cerraha uygulanan geri bildirimi, $k$ ise ölçekleme katsayısını gösterir. Örneğin $k=0.4$ seçildiğinde 5 newtonluk temas, cerraha 2 newton olarak hissettirilir. Böylece bilgi korunurken yorulma ve ani tepki riski azaltılabilir.

Aynı sistem cerrahın el titremesini de filtreleyebilir. İnsan elindeki küçük, istemsiz hareketler yazılımla bastırılırken bilinçli hareketler küçültülerek robot ucuna aktarılır. Cerrah kontrol kolunu 10 milimetre hareket ettirdiğinde aletin yalnızca 1 milimetre ilerlemesi mümkün olabilir.

Hassas operasyonlardaki rolü

Haptik geri bildirim özellikle mikrocerrahi, beyin cerrahisi, damar onarımı ve hassas dikiş işlemlerinde değerlidir. İnce bir damarı tutarken fazla kuvvet uygulamak dokuyu zedeleyebilir; yetersiz kuvvet ise iğnenin veya dokunun kaymasına neden olabilir. Ölçülebilir kuvvet sınırları, cerrahı tehlikeli bölgeye yaklaşırken uyarabilir.

Basitleştirilmiş bir güvenlik denetimi şöyle modellenebilir:

def haptik_uyari(olculen_kuvvet, guvenli_sinir):
    oran = olculen_kuvvet / guvenli_sinir

    if oran >= 1.0:
        return 'hareketi durdur ve güçlü titreşim üret'
    elif oran >= 0.8:
        return 'kontrol kolundaki direnci artır'
    return 'normal geri bildirim uygula'

print(haptik_uyari(1.7, 2.0))

Bu örnek, ölçülen kuvvet güvenli sınırın yüzde 80’ine ulaştığında direnci artırır. Gerçek sistemlerde kararlar çok daha yüksek frekansta alınır; sensör birleştirme, mekanik modeller ve hata toleranslı kontrol algoritmaları kullanılır.

Her dokunuş kusursuz mu?

Henüz değil. İletişim gecikmesi, sensör gürültüsü, sterilizasyon gereksinimleri ve çok küçük kuvvetlerin doğru ölçülmesi önemli mühendislik problemleridir. Gecikmiş geri bildirim, cerrahın gerçekte sona ermiş bir teması hâlâ hissediyormuş gibi tepki vermesine yol açabilir. Bu nedenle kararlı bir kontrol döngüsü, yalnızca güçlü motorlardan değil, doğru zamanlama ve güvenilir yazılımdan doğar.

Gelecekte yapay zekâ, farklı dokuların haptik imzalarını sınıflandırarak cerraha ek uyarılar sunabilir. Ancak amaç cerrahın kararını devralmak değil, görüşüne güvenilir bir dokunma kanalı eklemektir. Kısacası haptik cerrahi robotlar, robotu daha kuvvetli değil, daha ölçülü ve daha hissedebilir hâle getirir.

``

Eklem sınırı ile tekillik aynı şey mi?

Hayır. Eklem sınırı, bir eklemin izin verilen konum aralığıdır:

Tekillik ise robotun Jacobian matrisinin rank kaybettiği konfigürasyondur. Uç efektör hızı ile eklem hızları arasındaki ilişki

şeklindedir. Kare bir Jacobian için $\det(J)=0$ olduğunda matematiksel tekillik oluşur. Kare olmayan sistemlerde en küçük tekil değer $\sigma_{\min}$ sıfıra yaklaştıkça tekillik riski artar.

Eklem sınırı doğrudan Jacobian’ı tekil yapmaz. Ancak planlayıcının kullanabileceği konfigürasyon uzayını daraltır. Normalde robot, tekil bölgenin çevresinden farklı bir dirsek veya bilek duruşuyla dolaşabilir. Bu alternatif eklem sınırını aşıyorsa planlayıcı tekilliğe yakın rotayı seçmek zorunda kalabilir.

Yörünge neden tehlikeli hâle gelir?

Ters hız kinematiğinde genellikle

kullanılır. Tekilliğe yaklaşırken sözde ters $J^{\dagger}$ çok büyük değerler üretebilir. Robot küçük bir Kartezyen hız için bile aşırı eklem hızı ister. İstenen kaçış yönü eklem sınırı tarafından engelleniyorsa durum daha da kötüleşir.

Örneğin altı eksenli bir kolun bilek eklemi üst sınıra dayanmış olsun. Uç efektör yönelimini korumak için aynı hareketi başka eklemler paylaşabilir; fakat kol tamamen uzanmışsa Jacobian da rank kaybedebilir. Böylece hem hareket serbestliği azalır hem de sayısal çözüm kararsızlaşır.

Planlayıcı bunu nasıl fark eder?

Manipülebilirlik ölçütü yaygın bir erken uyarıdır:

$w(q)$ küçüldükçe robot tekilliğe yaklaşır. Eklem sınırına yakınlık için ayrıca ceza fonksiyonu tanımlanabilir:

Aşağıdaki Python kodu, bir aday konfigürasyonun en küçük tekil değerini ve eklem sınırı cezasını hesaplar:

import numpy as np

def trajectory_cost(q, J, q_min, q_max):
    # Küçük sigma, tekilliğe yakınlığı gösterir.
    sigma_min = np.linalg.svd(J, compute_uv=False)[-1]

    # Eklem aralığının merkezinden uzaklaşmayı cezalandırır.
    q_mid = (q_min + q_max) / 2.0
    span = q_max - q_min
    limit_cost = np.sum(((q - q_mid) / span) ** 2)

    singularity_cost = 1.0 / (sigma_min + 1e-4)
    return singularity_cost + 2.0 * limit_cost

Bu maliyet, RRT*, CHOMP veya optimizasyon tabanlı planlayıcılarda aday yolları karşılaştırmak için kullanılabilir. Katsayılar robotun hız, güvenlik ve görev önceliklerine göre ayarlanmalıdır.

Kaçınma stratejileri

Özetle eklem sınırları tekilliğin matematiksel sebebi değildir; fakat güvenli kaçış yollarını kapatan güçlü bir tetikleyicidir. Sağlam bir planlayıcı konum sınırlarını, Jacobian kondisyonunu, hız limitlerini ve alternatif kinematik dalları birlikte değerlendirmelidir. Robotun hedefe ulaşması yetmez; hedefe eklemlerini düğüm yapmadan ulaşması gerekir.

``

Collections Framework nedir?

Collections Framework; veri yapılarından, bunlarla çalışan arayüzlerden ve yardımcı algoritmalardan oluşan standart bir Java API’sidir. Hiyerarşinin merkezinde Collection<E> arayüzü bulunur. List<E> ve Set<E> bu arayüzden türetilirken Map<K, V>, anahtar-değer modeli nedeniyle ayrı bir hiyerarşide yer alır.

Buradaki E, koleksiyonda saklanan elemanın türünü belirten generic parametredir. Örneğin List<String>, yalnızca metin saklamayı amaçlar. Bu yaklaşım çalışma zamanında ortaya çıkabilecek tür hatalarını derleme aşamasına taşır.

List: Sıralı veri dünyası

List, elemanların eklenme sırasını korur ve aynı değerin birden fazla kez bulunmasına izin verir. En yaygın uygulaması ArrayList sınıfıdır. İndeksle erişim ortalama $O(1)$ zaman karmaşıklığına sahiptir. Ancak listenin ortasına eleman eklemek, sonraki elemanların kaydırılmasını gerektirdiğinden $O(n)$ olabilir.

List<String> diller = new ArrayList<>();
diller.add("Java");
diller.add("Python");
diller.add("Java");

System.out.println(diller.get(0)); // Java
diller.remove("Python");

Bu kod sıralı bir dil listesi oluşturur. İkinci Java kabul edilir çünkü List tekrarları yasaklamaz. Sıkça baştan veya ortadan ekleme yapılacaksa bağlantılı düğümler kullanan LinkedList düşünülebilir; fakat çoğu genel senaryoda ArrayList daha iyi başlangıç seçimidir.

Set: Tekrarlara geçit yok

Set, her elemanın yalnızca bir kez bulunmasını sağlar. HashSet, elemanları hash değerleri üzerinden yönetir ve ekleme, silme, arama işlemlerinde ortalama $O(1)$ performans sunar.

Set<String> roller = new HashSet<>();
roller.add("admin");
roller.add("editor");
roller.add("admin");

System.out.println(roller.size()); // 2

İkinci admin eklenmez. Ekleme sırası önemliyse LinkedHashSet, elemanların doğal veya özel bir kurala göre sıralanması gerekiyorsa TreeSet kullanılabilir. TreeSet işlemleri dengeli ağaç yapısı nedeniyle genellikle $O(\log n)$ maliyetindedir.

Map: Anahtarı ver, değeri al

Map, verileri anahtar-değer çiftleri hâlinde saklar. Telefon rehberindeki isim-numara ilişkisi buna güzel bir örnektir. HashMap, benzersiz anahtarlar kullanır; aynı anahtarla yeniden değer eklenirse eski değer güncellenir.

Map<Integer, String> kullanicilar = new HashMap<>();
kullanicilar.put(101, "Ayşe");
kullanicilar.put(102, "Mert");
kullanicilar.put(101, "Deniz");

String ad = kullanicilar.getOrDefault(101, "Bulunamadı");
System.out.println(ad); // Deniz

Harita üzerinde güvenli dolaşmak için entrySet() kullanılabilir:

for (Map.Entry<Integer, String> kayit : kullanicilar.entrySet()) {
    System.out.println(kayit.getKey() + ": " + kayit.getValue());
}

Yardımcı işlemler ve doğru seçim

Collections yardımcı sınıfı; sıralama, ters çevirme ve en küçük elemanı bulma gibi algoritmalar sağlar.

List<Integer> puanlar = new ArrayList<>(List.of(70, 95, 82));
Collections.sort(puanlar);
Collections.reverse(puanlar);

Seçim kuralı basittir: Konum ve sıra önemliyse List, benzersizlik önemliyse Set, bir anahtardan değere ulaşılacaksa Map kullanılır. Ayrıca HashMap ve HashSet içinde özel nesneler saklanırken equals() ile hashCode() metotlarının tutarlı tanımlanması gerekir. Eşit kabul edilen iki nesne için şu ilişki korunmalıdır: $a.equals(b) \Rightarrow a.hashCode() = b.hashCode()$. Doğru koleksiyon seçimi hem kodu okunabilir kılar hem de uygulamanın gereksiz yere kaplumbağa moduna geçmesini engeller.

``

Lambda ifadesinin teorik temeli

Klasik nesne yönelimli programlamada davranışlar genellikle sınıfların metotları içinde bulunur. Fonksiyonel yaklaşımda ise bir işlem, başka bir işleme parametre olarak aktarılabilir veya sonuç olarak döndürülebilir. Matematikteki bir fonksiyonu şöyle gösterebiliriz:

Java’daki karşılığı (x) -> x * 2 biçiminde yazılabilir. Burada sol taraf parametreleri, -> operatörü bağlantıyı, sağ taraf ise çalıştırılacak gövdeyi temsil eder.

Genel lambda söz dizimi şöyledir:

(parametreler) -> ifade

Birden fazla komut varsa süslü parantez ve gerektiğinde return kullanılır:

(a, b) -> {
    int toplam = a + b;
    return toplam;
}

Lambda kendi başına havada duran isimsiz bir metot değildir. Java, lambdanın hangi parametreleri alacağını ve hangi türü döndüreceğini bir fonksiyonel arayüzün tek soyut metodundan öğrenir. Bu ilişkiye hedef tipleme denir.

Fonksiyonel arayüz nedir?

Yalnızca bir soyut metoda sahip arayüzler fonksiyonel arayüz olarak kullanılabilir. @FunctionalInterface zorunlu değildir; ancak yanlışlıkla ikinci bir soyut metot eklenmesini engellediği için önerilir.

@FunctionalInterface
interface Hesaplayici {
    int hesapla(int a, int b);
}

Bu arayüze farklı davranışlar bağlayabiliriz:

Hesaplayici topla = (a, b) -> a + b;
Hesaplayici carp = (a, b) -> a * b;

System.out.println(topla.hesapla(4, 3)); // 7
System.out.println(carp.hesapla(4, 3));  // 12

Aynı arayüz iki farklı algoritmayı temsil eder. Böylece “hangi işlem yapılacak?” kararı, işlemi kullanan koddan ayrılır.

Anonim sınıf ile lambda karşılaştırması

Lambda ifadelerinden önce aynı davranış çoğunlukla anonim sınıfla yazılırdı:

Hesaplayici topla = new Hesaplayici() {
    @Override
    public int hesapla(int a, int b) {
        return a + b;
    }
};

Lambda her zaman daha iyi değildir. İşlem uzuyor, çok sayıda koşul içeriyor veya yeniden kullanılacak hâle geliyorsa isimlendirilmiş bir metot daha anlaşılır olabilir.

Hazır fonksiyonel arayüzler

Java, java.util.function paketinde sık kullanılan arayüzleri hazır sunar:

Predicate<Integer> ciftMi = sayi -> sayi % 2 == 0;
Function<String, Integer> uzunluk = metin -> metin.length();
Consumer<String> yazdir = metin -> System.out.println(metin);
Supplier<Double> rastgele = () -> Math.random();

Örneğin çiftlik kontrolü matematiksel olarak $n \bmod 2 = 0$ koşuluna dayanır. Predicate, bu koşulu yeniden kullanılabilir bir davranışa dönüştürür.

Stream API ile kullanım

Lambdaların en eğlenceli sahnesi Stream API’dir:

List<String> isimler = List.of("Ada", "Ahmet", "Ece", "Mehmet");

isimler.stream()
      .filter(isim -> isim.length() >= 4)
      .map(String::toUpperCase)
      .forEach(System.out::println);

filter eleme, map dönüştürme, forEach ise sonuçları tüketme davranışını alır. String::toUpperCase bir metot referansıdır ve uygun lambda ifadesinin daha kısa gösterimidir.

Sonuç olarak lambda ifadeleri yalnızca sözdizimsel şeker değildir; davranışları arayüzler üzerinden aktararak gevşek bağlı, test edilebilir ve ifade gücü yüksek kod yazmamızı sağlar. Kısa işlemlerde lambda, karmaşık iş kurallarında ise anlamlı isimlere sahip metotlar kullanmak en dengeli yaklaşımdır.