Bir multiplayer maçına giriyorsunuz: Takım arkadaşınız yanlış koridora gidiyor, biri mikrofonu sonuna kadar açıyor ve henüz ikinci dakika dolmadan sohbet kutusunda küçük çaplı bir iç savaş başlıyor. Bu davranışlar yalnızca “kötü oyunculuk kültürü” değildir. Anonimlik, rekabet, grup kimliği ve sosyal mühendislik aynı dijital arenada buluştuğunda insanların yüz yüze ortamda sergilemeyeceği davranışlar ortaya çıkabilir. ``

Anonimlik neden freni gevşetir?

Sosyal psikolojide çevrimiçi disinhibisyon etkisi, kişinin dijital ortamda daha dürtüsel davranmasını açıklar. Oyuncu gerçek adını, yüzünü ve sosyal çevresini göstermediğinde davranışlarının kişisel itibarına zarar verme ihtimali azalır. “Ben” yerine geçici bir kullanıcı adı öne çıkar.

Bu durumu basitleştirilmiş bir davranış modeliyle gösterebiliriz:

Burada $T$ toksik davranış olasılığını, $A$ anonimlik düzeyini, $R$ rekabet baskısını, $G$ grup kutuplaşmasını, $H$ hesap verebilirliği ve $C$ davranışın algılanan maliyetini temsil eder. Bu bilimsel bir teşhis formülü değil, ilişkileri anlamayı kolaylaştıran kavramsal bir modeldir. Anonimlik ve rekabet yükselirken yaptırım ihtimali düşerse toksisite için elverişli bir ortam oluşur.

Rekabet, grup kimliği ve günah keçileri

Dereceli maçlarda puan kaybetmek, yalnızca sanal bir sayı kaybı gibi görünmeyebilir. Oyuncunun beceri algısı ve grup içindeki statüsü de tehdit edilir. İnsanlar böyle anlarda başarısızlığı kendi kararları yerine takım arkadaşlarına bağlamaya eğilimlidir. Bu, kendine hizmet eden yanlılık olarak bilinir.

Takımlar ayrıca hızlı biçimde “biz” ve “onlar” ayrımı üretir. Rakip insan olmaktan çıkıp engel gibi algılandığında empati azalabilir. Takım içinde çoğunluğun bir oyuncuyu suçlaması ise sorumluluğun dağılmasına yol açar: Herkes hakarete katıldığı için kimse kendisini asıl fail olarak görmez.

Sosyal mühendislik oyuna nasıl sızar?

Sosyal mühendislik, teknik açık yerine güven, korku, merak veya otorite algısını hedefler. Saldırgan; takım arkadaşı, turnuva yöneticisi ya da destek görevlisi gibi davranarak bağlantıya tıklatmaya, hesap bilgisini almaya veya oyuncuyu başka platforma taşımaya çalışabilir. “Hemen doğrulamazsan hesabın kapanacak” mesajı, zaman baskısıyla eleştirel düşünmeyi devre dışı bırakmayı amaçlar.

Toksik atmosfer saldırgana avantaj sağlar. Öfkeli veya panik hâlindeki oyuncu, normalde sorgulayacağı bir isteğe daha hızlı tepki verebilir. Bu nedenle güvenliğin ilk kuralı basittir: Şifre, doğrulama kodu ve kurtarma anahtarı sohbet üzerinden paylaşılmaz.

Yazılımla erken uyarı mümkün mü?

Moderasyon sistemleri mesajları yalnızca yasaklı kelimelerle değil; tekrar, tehdit, büyük harf kullanımı ve rapor geçmişi gibi sinyallerle değerlendirebilir. Aşağıdaki örnek, açıklanabilir basit bir risk puanı üretir:

def risk_puani(mesaj, tekrar, gecmis_rapor):
    tehditler = ["hesabını kapatırım", "adresini bulurum"]
    puan = sum(ifade in mesaj.lower() for ifade in tehditler) * 3
    puan += min(tekrar, 4)
    puan += min(gecmis_rapor, 5) * 0.5
    puan += 1 if mesaj.isupper() and len(mesaj) > 12 else 0
    return puan

Bu kod otomatik ceza vermek yerine inceleme sırası oluşturabilir. Dil, mizah ve bağlam değiştiği için insan denetimi gereklidir; aksi hâlde yanlış pozitifler ve kültürel önyargılar oluşabilir.

Daha sağlıklı bir arena

Etkili çözüm yalnızca oyuncuları susturmak değildir. Hızlı raporlama, davranış geri bildirimi, kademeli yaptırım, pozitif takım ödülleri ve iki faktörlü kimlik doğrulama birlikte kullanılmalıdır. Oyuncular da öfkeliyken yanıt vermemeli, şüpheli bağlantıları açmamalı ve saldırganı engelleyip kanıtları platforma iletmelidir. İyi tasarlanmış sistemler insan doğasını değiştirmez; fakat kötü davranışın ödülünü azaltıp iş birliğini daha görünür ve değerli hâle getirebilir.

C# ile geliştirdiğimiz özel sınıflar, varsayılan olarak +, -, >, == gibi operatörlerin ne anlama geldiğini bilmez. Örneğin iki vektörü vektor1 + vektor2 biçiminde toplamak istersek derleyici doğal olarak şaşırır. Operatör aşırı yükleme, bu sembollere kendi nesnelerimiz için anlam kazandırmamızı sağlar. Böylece kod hem matematiksel gösterime yaklaşır hem de daha okunabilir hâle gelir.

``

Operatör aşırı yükleme nedir?

Operatör aşırı yükleme, mevcut bir operatörün özel bir tür üzerindeki davranışını tanımlamaktır. Burada yeni bir operatör icat etmeyiz; C# tarafından desteklenen operatörlerden birini yeniden anlamlandırırız.

Örneğin iki boyutlu bir vektörümüz şu şekilde gösterilsin:

İki vektörün toplamı ise bileşenlerin ayrı ayrı toplanmasıyla bulunur:

Bu matematiksel kuralı C# sınıfına taşıyarak + operatörünü programlayabiliriz.

Temel söz dizimi

Aşırı yüklenen operatörler public ve static olarak tanımlanmalıdır. Metot adı yerine operator anahtar sözcüğü ve ilgili sembol kullanılır.

public class Vektor
{
    public double X { get; }
    public double Y { get; }

    public Vektor(double x, double y)
    {
        X = x;
        Y = y;
    }

    public static Vektor operator +(Vektor sol, Vektor sag)
    {
        return new Vektor(sol.X + sag.X, sol.Y + sag.Y);
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

Bu metot iki Vektor nesnesini alır ve toplamı temsil eden yeni bir nesne döndürür. Mevcut nesneleri değiştirmemek, özellikle matematiksel değer türlerinde daha güvenli ve tahmin edilebilir bir tasarımdır.

var a = new Vektor(2, 3);
var b = new Vektor(4, 1);
var toplam = a + b;

Console.WriteLine(toplam); // (6, 4)

Normalde Vektor.Topla(a, b) gibi bir metot yazılabilirdi. Ancak a + b, işlemin niyetini çok daha hızlı anlatır.

\vert Yaklaşım \vert Kullanım \vert Okunabilirlik \vert Matematiksel uyum \vert \vert —\vert —\vert —:\vert —:\vert \vert Normal metot \vert Vektor.Topla(a, b) \vert Orta \vert Düşük \vert \vert Operatör \vert a + b \vert Yüksek \vert Yüksek \vert \vert Elle hesaplama \vert new Vektor(a.X+b.X, a.Y+b.Y) \vert Düşük \vert Orta \vert

İlişkisel operatörleri yüklemek

Vektörleri büyüklüklerine göre karşılaştırabiliriz. Bir vektörün uzunluğu Pisagor bağıntısıyla hesaplanır:

Karşılaştırma sırasında karekök almaya gerek yoktur. Çünkü pozitif değerlerde $a^2 > b^2$ ise $a > b$ olur.

public double UzunlukKaresi => X * X + Y * Y;

public static bool operator >(Vektor sol, Vektor sag)
{
    return sol.UzunlukKaresi > sag.UzunlukKaresi;
}

public static bool operator <(Vektor sol, Vektor sag)
{
    return sol.UzunlukKaresi < sag.UzunlukKaresi;
}

C# bazı operatörlerin çiftler hâlinde tanımlanmasını ister. < ekleniyorsa >, <= ekleniyorsa >=, == ekleniyorsa != de tanımlanmalıdır. Derleyici bu konuda “Birini çağırdıysan arkadaşını da getir!” yaklaşımındadır.

Eşitlikte dikkat edilmesi gerekenler

== operatörü yüklendiğinde Equals ve GetHashCode metotları da uyumlu biçimde ezilmelidir. Aksi hâlde operatöre göre eşit olan iki nesne, bir Dictionary veya HashSet içinde farklı kabul edilebilir. Eşitlik tanımı uygulamanın her noktasında aynı mantığı izlemelidir.

Operatör aşırı yükleme güçlüdür; fakat yalnızca operatörün anlamı kullanıcı için doğal olduğunda tercih edilmelidir. Bir Musteri nesnesini başka bir müşteriyle toplamak belirsizken, para, tarih aralığı, karmaşık sayı veya vektörleri toplamak oldukça anlaşılırdır. Ayrıca operatörün önceliği ve operand sayısı değiştirilemez. Doğru kullanıldığında bu özellik, C++’taki benzer yaklaşım gibi özel nesneleri dilin doğal parçalarıymış gibi kullanmamızı sağlar.

``

Bilinçli hareketten otomatik tepkiye

Yeni başlayan bir speedcuber, karşısındaki deseni tanımaya ve uygun algoritmayı hatırlamaya çalışır. Deneyimli biri ise deseni gördüğü anda ellerini harekete geçirir. Benzer biçimde acemi bir oyuncu hangi tuşa basacağını düşünürken deneyimli oyuncu saldırıdan kaçıp karşı hamle yapabilir.

Bu gelişim motor hafızası olarak adlandırılır. Ancak kasların kendi başına bilgi depoladığı düşünülmemelidir. Öğrenme; beyin, sinir sistemi, görsel algı ve kas koordinasyonu arasında kurulan bağlantıların güçlenmesidir. Bir hareket dizisi tekrarlandıkça karar verme maliyeti azalır ve işlem otomatikleşir.

Basitleştirilmiş bir öğrenme modeli şöyle gösterilebilir:

Burada $T(n)$, $n$ tekrar sonrasındaki uygulama süresi; $T_0$ başlangıç süresi; $T_{min}$ ulaşılabilecek yaklaşık alt sınır; $k$ ise öğrenme hızıdır. İlk tekrarlar büyük gelişmeler sağlarken ilerleyen aşamalarda her küçük iyileştirme daha fazla emek ister. Yani 60 saniyeden 30 saniyeye düşmek, 12 saniyeden 11 saniyeye düşmekten çoğu zaman daha kolaydır.

İki dünyanın ortak mekanikleri

Her iki alanda da uzmanlık yalnızca “daha hızlı hareket etmek” değildir. Asıl kazanç, gereksiz kararları ve hareketleri ortadan kaldırmaktır. Speedcubing’de buna düşük hamle sayısı, akıcı dönüşler ve iyi look-ahead eşlik eder. Oyunlarda ise doğru rota, uygun zamanlama ve minimum girdiyle maksimum sonuç önem kazanır.

Tekrar var, tekrar var

Aynı diziyi düşünmeden yüz kez yapmak her zaman verimli değildir. Hatalı hareket tekrarlandığında beyin o hatayı da otomatikleştirebilir. Bu nedenle bilinçli pratik, rastgele tekrardan daha değerlidir.

Örneğin bir speedcuber yalnızca zorlandığı algoritmayı çalışabilir. Bir oyuncu da tüm bölümü yeniden oynamak yerine problemli sıçramayı, komboyu veya nişan geçişini ayrı bir antrenman ortamında tekrarlayabilir.

Gelişimi veriye dönüştürmek

Aşağıdaki küçük Python kodu, pratik sürelerinin ortalamasını ve tutarlılığını ölçer:

from statistics import mean, pstdev

sureler = [18.4, 17.9, 18.1, 17.6, 17.8]

print('Ortalama:', round(mean(sureler), 2))
print('Sapma:', round(pstdev(sureler), 2))

Ortalama süre genel performansı, standart sapma ise denemeler arasındaki değişkenliği gösterir. Daha düşük ortalama hızlanmayı; daha düşük sapma ise becerinin güvenilir biçimde otomatikleştiğini anlatır. Aynı yaklaşım küp çözme sürelerine, bölüm tamamlama kayıtlarına veya hedef vurma testlerine uygulanabilir.

Sonuç: Hız, düşünmemek değil doğru düşünmektir

Speedcubing ve oyun optimizasyonunda ustalık, zihni tamamen devre dışı bırakmak anlamına gelmez. Temel hareketler motor hafızasına aktarılınca bilinçli dikkat daha üst düzey problemlere ayrılır. Eller mevcut hamleyi tamamlarken zihin bir sonraki deseni, rotayı veya riski değerlendirebilir. Gerçek hız böyle doğar: doğru hareketi öğrenmek, onu parçalara ayırmak, kontrollü biçimde tekrarlamak ve sonunda akışın doğal bir parçasına dönüştürmek.

Neden otonomi gerekli?

Bir komutun Dünya’dan Mars’a gidip sonucunun geri dönmesi için gereken yaklaşık süre şöyle düşünülebilir:

Burada $d$ gezegenler arasındaki mesafe, $c$ ışık hızı ve $T_{işleme}$ görev merkezindeki değerlendirme süresidir. Radyo sinyalleri ışık hızında ilerlese bile mesafe ortadan kalkmaz. Üstelik bant genişliği sınırlıdır; rover sürekli yüksek çözünürlüklü görüntü gönderemez.

Güncel görevlerde çoğunlukla karma yaklaşım kullanılır. Bilim insanları hedef bölgeyi belirler; rover ise birkaç metrelik hareket sırasında taşlardan, çukurlardan ve tehlikeli eğimlerden kaçınır.

Rover çevresini nasıl görüyor?

Otonom sürüşün ilk aşaması algılamadır. Stereo kameralar aynı sahneyi iki farklı noktadan görüntüler. İnsan gözlerindeki derinlik algısına benzeyen bu yöntemle pikseller arasındaki kayma, yani disparity, ölçülür. Basitleştirilmiş derinlik bağıntısı şöyledir:

$Z$ engele olan uzaklığı, $f$ kameranın odak uzaklığını, $B$ iki kamera arasındaki mesafeyi ve $\Delta x$ görüntülerdeki piksel farkını gösterir. Rover bu verilerden üç boyutlu bir nokta bulutu ve yerel arazi haritası üretir.

Her arazi parçasına bir maliyet atanabilir:

Burada $E$ eğim, $S$ zeminin gevşekliği, $R$ kaya riski ve $D$ hedefe olan uzaklıktır. Ağırlıklar görev önceliklerine göre ayarlanır. Böylece en kısa rota yerine en güvenli ve enerji açısından uygun rota seçilebilir.

Rota planlama nasıl çalışıyor?

Harita hücrelere veya düğümlere ayrıldıktan sonra A, Dijkstra ya da örnekleme tabanlı algoritmalar kullanılabilir. A algoritmasının temel değerlendirmesi şöyledir:

$g(n)$ başlangıçtan mevcut noktaya kadar gerçek maliyeti, $h(n)$ ise hedefe kalan tahmini maliyeti temsil eder.

from heapq import heappush, heappop

def guvenli_adimlar(baslangic, hedef, komsular):
    kuyruk = [(0, baslangic, [])]
    ziyaret = set()

    while kuyruk:
        maliyet, konum, yol = heappop(kuyruk)
        if konum == hedef:
            return yol + [konum]
        if konum in ziyaret:
            continue

        ziyaret.add(konum)
        for yeni, arazi_riski in komsular(konum):
            if yeni not in ziyaret:
                heappush(kuyruk, (
                    maliyet + arazi_riski,
                    yeni,
                    yol + [konum]
                ))
    return None

Bu sade örnek, komşu konumları arazi riskine göre kuyruğa ekler. Gerçek rover yazılımı tekerlek kaymasını, enerji tüketimini, gövde yüksekliğini ve iletişim fırsatlarını da hesaba katar.

Karar vermek yalnızca ilerlemek değildir

Rover risk yükseldiğinde durabilir, yeni fotoğraflar çekebilir veya farklı bir rota hesaplayabilir. Tekerleklerin dönüşüyle beklenen hareket karşılaştırılarak kayma tahmin edilir. Motorlar çalıştığı hâlde konum değişmiyorsa sistem gevşek kum ihtimalini fark eder.

Mars’ta başarılı otonomi, rover’ın “zekice cesur” değil, ölçülü biçimde temkinli olmasıdır. Çünkü milyonlarca kilometre uzaktaki bir robot için en iyi karar bazen yeni bir keşfe koşmak değil, durup Dünya’daki ekibin talimatını beklemektir.

Gökyüzündeki hareketler ilk bakışta kusursuz bir saat mekanizması gibi görünür. Ancak sisteme üçüncü bir gök cismi eklendiğinde işler hızla kozmik bir bilardo masasına dönüşür! N-cisim problemi; yıldızların, gezegenlerin veya galaksilerin karşılıklı kütle çekimi altında nasıl hareket ettiğini bulmayı amaçlar. Genel bir analitik çözümü bulunmadığından bilgisayarlarla küçük zaman adımları hâlinde yaklaşık sonuçlar hesaplarız.

``

Newton’dan simülasyona

İki cismin arasındaki çekim kuvveti Newton yasasıyla hesaplanır:

Burada $G$ kütle çekim sabiti, $m_1$ ve $m_2$ kütleler, $r$ ise cisimler arasındaki uzaklıktır. Fakat yönü de hesaba katmak için vektörel ifadeye ihtiyacımız vardır. $i$ cisminin $j$ nedeniyle kazandığı ivme şöyledir:

Toplam ivme, diğer bütün cisimlerin katkılarının toplamıdır:

Formüldeki $\epsilon$, iki cisim aşırı yaklaştığında ivmenin sonsuza gitmesini engelleyen yumuşatma parametresidir. Bu değer fiziksel bir yasa değil, sayısal simülasyonu kararlı tutan küçük bir emniyet yastığıdır.

Neden adım adım hesaplıyoruz?

İvme sürekli değiştiği için gelecekteki konumu tek hamlede bulamayız. Zamanı $\Delta t$ büyüklüğünde dilimlere ayırır, her dilimde ivme, hız ve konumu güncelleriz. Basit Euler yöntemi kolaydır fakat uzun simülasyonlarda enerji hatası biriktirir. Leapfrog yöntemi ise hız ve konumu birbirinin arasına yerleştirerek daha kararlı sonuç verir.

Python ile temel uygulama

Aşağıdaki kod, iki boyutlu bir sistemde bütün cisimlerin ivmelerini hesaplar ve Leapfrog adımı uygular:

import numpy as np

G = 1.0
EPS = 0.01
DT = 0.001

def accelerations(pos, mass):
    n = len(mass)
    acc = np.zeros_like(pos)

    for i in range(n):
        for j in range(n):
            if i == j:
                continue

            delta = pos[j] - pos[i]
            distance2 = np.dot(delta, delta) + EPS**2
            acc[i] += G * mass[j] * delta / distance2**1.5

    return acc

def leapfrog_step(pos, vel, mass):
    # Hızı yarım adım ilerlet.
    acc = accelerations(pos, mass)
    vel += 0.5 * DT * acc

    # Yeni hızla konumu tam adım ilerlet.
    pos += DT * vel

    # Yeni konumdaki ivmeyle hız adımını tamamla.
    acc = accelerations(pos, mass)
    vel += 0.5 * DT * acc
    return pos, vel

mass = np.array([1000.0, 1.0, 0.5])
pos = np.array([[0.0, 0.0], [1.0, 0.0], [-1.5, 0.0]])
vel = np.array([[0.0, 0.0], [0.0, 31.6], [0.0, -25.8]])

for _ in range(10000):
    pos, vel = leapfrog_step(pos, vel, mass)

İç içe döngüler nedeniyle hesaplama maliyeti $O(N^2)$ olur: cisim sayısı iki katına çıktığında etkileşim sayısı yaklaşık dört kat artar. Binlerce cisim için Barnes–Hut algoritması, uzaktaki cisimleri gruplandırarak maliyeti yaklaşık $O(N\log N)$ seviyesine indirebilir.

Sonuçları değerlendirirken yalnızca güzel yörüngelere bakmak yeterli değildir. Toplam enerji ve momentum yaklaşık korunmalıdır. Enerji sürekli artıyor veya azalıyorsa zaman adımı fazla büyük olabilir. İşte N-cisim simülasyonunun temel sırrı budur: doğru fizik kadar, hatayı kontrol eden doğru sayısal yöntem de gerekir.

``

Küçük ama görev kritik bir bilgisayar

MIT Instrumentation Laboratory tarafından geliştirilen AGC, Komuta Modülü ve Ay Modülü’nde kullanıldı. Yaklaşık 2,048 MHz saat frekansına sahipti; ancak bu değer modern işlemcilerle doğrudan karşılaştırılmamalıdır. Temel bellek birimi 15 veri biti ve bir eşlik bitinden oluşan 16 bitlik sözcüktü.

Bellek iki ana bölüme ayrılıyordu:

Modern ölçüyle yazılabilir kapasite yaklaşık olarak şöyle düşünülebilir:

Fakat eşlik bitleri, adresleme düzeni ve kullanılabilir alanlar dikkate alındığında pratik çalışma alanı oldukça sınırlıydı. Sıkça söylenen “2 KB” ifadesi de bu kısıtlı erasable memory yapısını özetler.

Core rope: Yazılımı gerçekten dokumak

AGC’nin kalıcı programı, core rope memory adı verilen özel bir bellekte saklanıyordu. Teller manyetik çekirdeklerin içinden geçirilirse bir, dışından geçirilirse sıfır temsil ediliyordu. Bu nedenle yazılım üretiminin son aşaması fiziksel dokuma sürecine benziyordu.

Bu yöntem zahmetliydi ama belleği güç kesintilerine ve uzay koşullarına karşı dayanıklı kılıyordu. Yazılım ekibi, gereksiz her komutu gerçek bir maliyet olarak görüyordu.

Executive: Erken dönem gerçek zamanlı işletim sistemi

AGC yazılımının kalbinde Executive bulunuyordu. Executive, görevleri önceliklerine göre çalıştıran kooperatif ve kesme destekli bir zamanlama mekanizmasıydı. Kritik bir görev geldiğinde daha düşük öncelikli işler ertelenebiliyordu. Böylece bilgisayar, aynı anda yapılacak çok iş varken “önce hangisi hayati?” sorusunu cevaplıyordu.

Basitleştirilmiş mantık şu sözde kodla gösterilebilir:

while görev_var:
    görev = en_yüksek_öncelikli_görevi_seç()

    if yeterli_kaynak_var(görev):
        görevi_çalıştır(görev)
    else:
        düşük_öncelikli_işleri_bırak()
        alarm_göster()

Bu kod, gerçek AGC kaynak kodu değildir; Executive’in kaynak yetersizliğinde önemli işleri koruma yaklaşımını anlatır. Ayrıca Interpreter adlı sanal makine benzeri katman, navigasyon hesaplarında kullanılan karmaşık vektör ve matris işlemlerini daha yoğun biçimde ifade ediyordu. Yani ekip, sınırlı komut kümesinin üzerine göreve özel bir soyutlama katmanı kurmuştu.

1201 ve 1202 alarmları neden başarı hikâyesidir?

Apollo 11’in inişi sırasında buluşma radarından gelen beklenmedik işler işlemci yükünü artırdı. AGC, 1201 ve 1202 program alarmlarını üretti. Bu alarmlar bilgisayarın tamamen çöktüğünü değil, Executive’in bütün işleri zamanında tamamlayamadığını bildiriyordu.

Yeniden başlatma koruması sayesinde sistem, düşük öncelikli görevleri bıraktı; uçuş kontrolü ve yönlendirme gibi kritik görevleri sürdürdü. Yaklaşım kabaca şu ilkeye dayanıyordu:

Bu, günümüzde gerçek zamanlı işletim sistemlerinde kullanılan önceliklendirme, hata yalıtımı ve kontrollü bozulma fikirlerinin erken ve etkileyici bir örneğidir.

DSKY ve kalıcı dersler

Astronotlar bilgisayarla DSKY adlı ekran-klavye birimi üzerinden, “verb” ve “noun” kodlarıyla iletişim kuruyordu. Örneğin fiil yapılacak işlemi, isim ise işlenecek veriyi belirtiyordu. Kullanımı alışılmadıktı ama az tuşla çok sayıda komut sunuyordu.

AGC bize iyi gömülü yazılımın yüksek donanım gücünden önce doğru öncelikler, öngörülebilir zamanlama ve güvenli hata davranışı gerektirdiğini öğretir. Ay’a inişi mümkün kılan şey sınırsız kaynaklar değil; her bitin, görevin ve hatanın titizlikle düşünülmesiydi.

``

Önce sinyalin matematiği

Bilgisayar, biyolojik sinyali belirli aralıklarla ölçülmüş sayılar dizisi olarak saklar. Sürekli zamanlı $x(t)$ sinyali, örnekleme sonrasında $x[n]$ biçimine dönüşür. Örnekleme frekansı $f_s$ ise iki ölçüm arasındaki süre $T_s = 1/f_s$ olur.

Nyquist ilkesine göre, frekansı $f_{max}$ olan bir bileşeni kaybetmeden yakalayabilmek için $f_s > 2f_{max}$ seçilmelidir. Örneğin 150 Hz’e kadar EMG bileşenleri incelenecekse 300 Hz teorik alt sınırdır; pratikte daha yüksek bir değer kullanılır.

Ham kayıt basitçe şöyle modellenebilir:

Burada $s[n]$ aradığımız biyolojik sinyal, $g[n]$ rastgele gürültü, $a[n]$ ise göz kırpması veya elektrot hareketi gibi artefaktlardır. Amaç her şeyi susturmak değil, $s[n]$ bileşenini bozmadan diğerlerini azaltmaktır.

Üç sinyal, üç farklı karakter

Bu farklılık önemlidir: EKG için uygun olan bir filtre, EMG’nin değerli yüksek frekanslarını silebilir. Yani tek bir “sihirli temizleme düğmesi” yoktur.

Temizleme hattı nasıl kurulur?

İlk adım çoğunlukla bant geçiren filtredir. Yüksek geçiren bölüm yavaş baz çizgisi kaymasını, alçak geçiren bölüm ise gereksiz yüksek frekansları azaltır. Ardından 50 Hz veya 60 Hz elektrik şebekesi parazitine karşı dar bir notch filtresi uygulanabilir.

Özellikle EEG’de göz kırpması birden fazla kanala yayılır. Bağımsız Bileşen Analizi, yani ICA, kayıtları istatistiksel olarak bağımsız kaynaklara ayırmaya çalışır. Göz hareketine benzeyen bileşen çıkarılıp kalanlar yeniden birleştirilebilir. Ancak yanlış bileşeni silmek, beynin gerçek etkinliğini de çöpe atabilir.

Python ile örnek filtreleme

Aşağıdaki örnek, 250 Hz ile kaydedilmiş bir EKG sinyaline 0.5–40 Hz bant geçiren Butterworth filtresi uygular:

import numpy as np
from scipy.signal import butter, sosfiltfilt

def ekg_temizle(sinyal, fs=250):
    # SOS gösterimi sayısal kararlılığı artırır.
    sos = butter(
        N=4,
        Wn=[0.5, 40],
        btype="bandpass",
        fs=fs,
        output="sos"
    )

    # İleri-geri filtreleme faz kaymasını önler.
    return sosfiltfilt(sos, np.asarray(sinyal))

sosfiltfilt, filtreyi iki yönde çalıştırarak dalgaların zamanını kaydırmaz. Bu, R tepesinin konumu gibi zamanlamaya bağlı EKG ölçümlerinde değerlidir. Bununla birlikte gerçek zamanlı sistemler gelecekteki örnekleri göremediği için aynı yöntemi doğrudan kullanamaz.

Temiz sinyal her zaman doğru sinyal değildir

Filtreleme sonrasında ham ve temizlenmiş kayıt mutlaka birlikte karşılaştırılmalıdır. Güç spektrumu, sinyal-gürültü oranı ve klinik dalga biçimleri kontrol edilmelidir. Örneğin sinyal-gürültü oranı $SNR = 10\log_{10}(P_s/P_g)$ ile ifade edilebilir; yükselmesi olumlu görünse de tanısal bir tepenin silinmediğini garanti etmez.

Sonuç olarak başarılı tıbbi sinyal işleme; matematik, biyoloji ve dikkatli doğrulamanın birleşimidir. Amaç grafiği güzel göstermek değil, hastaya ait gerçek bilgiyi güvenilir biçimde korumaktır.

Opsiyon nedir?

Opsiyon, sahibine belirli bir varlığı gelecekte belirli bir kullanım fiyatından alma veya satma hakkı verir. Call opsiyonu alma, put opsiyonu ise satma hakkıdır. Buradaki kritik kelime “hak”tır: Opsiyon sahibi işlemi gerçekleştirmek zorunda değildir.

Burada $S_T$ vade sonundaki varlık fiyatını, $K$ ise kullanım fiyatını gösterir.

Modelin teorik zemini

Black-Scholes, varlık fiyatının geometrik Brown hareketi izlediğini varsayar:

Bu denklemde $\mu$ beklenen getiri oranı, $\sigma$ volatilite ve $dW_t$ rastgele şoku temsil eder. Geometrik yapı sayesinde fiyatın negatif olması engellenir. Model ayrıca işlem maliyeti bulunmadığını, risksiz faiz oranının sabit olduğunu, varlığın sürekli alınıp satılabildiğini ve piyasanın arbitraja izin vermediğini kabul eder.

Asıl matematiksel sihir, opsiyon ile temel varlıktan oluşturulan delta-nötr portföyde gerçekleşir. Portföy çok kısa bir süre için fiyat hareketlerine karşı dengelenirse rastgelelik ortadan kaldırılabilir. Risksiz hale gelen portföy, arbitraj olmaması nedeniyle risksiz faiz oranıyla büyümelidir. Bu fikir şu kısmi diferansiyel denklemi doğurur:

Avrupa tipi, temettüsüz bir call opsiyonunun kapalı form çözümü şöyledir:

$N(x)$ standart normal dağılımın kümülatif dağılım fonksiyonudur. $S_0$ bugünkü fiyatı, $T$ vadeye kalan süreyi ve $r$ sürekli bileşik risksiz faiz oranını belirtir.

Algoritmik uygulama

Formülü Python ile doğrudan hesaplayabiliriz:

from math import log, sqrt, exp, erf

def normal_cdf(x):
    # Standart normal dağılımın kümülatif olasılığını hesaplar.
    return 0.5 * (1.0 + erf(x / sqrt(2.0)))

def black_scholes_call(S, K, T, r, sigma):
    if T <= 0:
        return max(S - K, 0.0)
    if sigma <= 0:
        return max(S - K * exp(-r * T), 0.0)

    d1 = (log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * sqrt(T))
    d2 = d1 - sigma * sqrt(T)
    return S * normal_cdf(d1) - K * exp(-r * T) * normal_cdf(d2)

fiyat = black_scholes_call(100, 105, 1, 0.04, 0.25)
print(f"Call fiyatı: {fiyat:.2f}")

Fonksiyon önce vade ve volatilite gibi sınır durumlarını denetler; ardından $d_1$ ve $d_2$ değerlerini hesaplayarak teorik call fiyatını üretir. Gerçek uygulamalarda temettü, piyasa spread’i ve veri kalitesi de hesaba katılmalıdır.

Parametreler fiyatı nasıl etkiler?

Modelin en tartışmalı girdisi volatilitedir. Piyasa fiyatından tersine hesaplanan örtük volatilite, yatırımcıların gelecekteki belirsizlik beklentisini yansıtır. Gerçekte volatilite sabit değildir; ayrıca fiyatlarda sıçramalar ve kalın kuyruklar görülebilir. Bu yüzden Black-Scholes nihai gerçek değil, güçlü bir referans modelidir: Mantığı öğrenildiğinde binom ağaçları, Monte Carlo simülasyonu ve stokastik volatilite modelleri çok daha anlaşılır hale gelir.

``

Nesne neden “dilimlenir”?

Bir türetilmiş sınıf nesnesini kavramsal olarak iki parçalı düşünebiliriz:

Temel sınıf türünde değer saklayan bir değişkenin kapasitesi ise yalnızca temel bölüme uygundur. Dolayısıyla aşağıdaki atamada Calisan nesnesinin Yazilimci sınıfına özgü kısmı hedef nesneye sığmaz. C++ bu kısmı hata vermeden dışarıda bırakır.

#include <iostream>
#include <string>

class Calisan {
public:
    std::string ad;

    virtual void tanit() const {
        std::cout << ad << ": Calisan\n";
    }
};

class Yazilimci : public Calisan {
public:
    std::string dil;

    void tanit() const override {
        std::cout << ad << ": " << dil << " gelistiricisi\n";
    }
};

int main() {
    Yazilimci y;
    y.ad = "Ada";
    y.dil = "C++";

    Calisan c = y; // Nesne dilimlenir
    c.tanit();     // Ada: Calisan
}

tanit() sanal olmasına rağmen sonuç değişmez. Çünkü c, artık bağımsız ve gerçek bir Calisan nesnesidir. İçinde Yazilimci kimliği bulunmadığından sanal fonksiyon mekanizmasının çağırabileceği türetilmiş davranış da kalmamıştır. virtual, dilimlenmeyi önlemez; yalnızca nesneye referans veya işaretçi üzerinden erişildiğinde dinamik türü kullanır.

Fonksiyon parametrelerindeki gizli tuzak

Dilimlenme yalnızca açık atamalarda oluşmaz. Temel sınıfı değer olarak kabul eden fonksiyonlar da aynı soruna yol açar:

void bilgiYaz(Calisan calisan) { // Değer ile alınıyor
    calisan.tanit();
}

Yazilimci y;
bilgiYaz(y); // Parametre oluşturulurken dilimlenir

Çözüm, parametreyi çoğunlukla sabit referansla almaktır:

void bilgiYaz(const Calisan& calisan) {
    calisan.tanit(); // Gerçek türe göre çağrı yapılır
}

Bu yöntem hem türetilmiş kimliği korur hem de gereksiz nesne kopyasını engeller. Fonksiyon nesneyi değiştirmeyecekse const kullanılması niyeti açıkça belirtir.

Koleksiyonlarda doğru tür seçimi

std::vector<Calisan> içine Yazilimci eklemek de nesneyi dilimler. Farklı türetilmiş türleri aynı koleksiyonda polimorfik olarak saklamak için akıllı işaretçiler kullanılabilir:

#include <memory>
#include <vector>

std::vector<std::unique_ptr<Calisan>> ekip;
ekip.push_back(std::make_unique<Yazilimci>());

for (const auto& kisi : ekip) {
    kisi->tanit();
}

Burada vektör nesnelerin kendilerini değil, temel sınıf türündeki sahiplik işaretçilerini saklar. Gerçek nesneler türetilmiş türleriyle yaşamaya devam eder. Temel sınıf üzerinden silme yapılacağı için yıkıcının da sanal olması gerekir:

virtual ~Calisan() = default;

Özetle, değer semantiği bilinçli bir temel sınıf kopyası istendiğinde uygundur; polimorfik davranış istendiğinde ise referanslar, işaretçiler ve akıllı işaretçiler tercih edilmelidir. Derleyicinin sessiz kalması işlemin zararsız olduğu anlamına gelmez: Nesnenin yalnızca üst dilimini servis edip geri kalanını mutfakta unutmuş olabilirsiniz.

``

Temel fikir: Harita, konum ve hedef

Navigasyon için üç şey gerekir: Önceden hazırlanmış bir harita, harita üzerinde belirlenmiş bir hedef ve hareket eden nesnenin güncel konumu. Cerrahî sistemlerde harita genellikle BT, MR veya ultrason görüntülerinden oluşturulur. Hareket eden nesne ise cerrahın kullandığı prob, matkap ya da iğnedir.

Buradaki önemli fark hassasiyettir. Otomobil navigasyonunda birkaç metrelik sapma kabul edilebilirken beyin veya omurga cerrahisinde birkaç milimetre bile kritik olabilir.

Kayıt: İki dünyayı üst üste getirmek

Bilgisayardaki görüntü koordinatları ile hastanın ameliyat masasındaki fiziksel koordinatları başlangıçta aynı değildir. Kayıt veya registration adı verilen işlem, bu iki koordinat sistemini eşleştirir. Cerrah hastanın üzerinde bilinen bazı anatomik noktaları işaretleyebilir ya da sistem yüzeyi tarayabilir.

Bir noktanın görüntü uzayından hasta uzayına dönüşümü basitleştirilmiş biçimde şöyle yazılır:

Burada $\mathbf{R}$ dönüşü temsil eden döndürme matrisi, $\mathbf{t}$ öteleme vektörü, $\mathbf{p}$ ise üç boyutlu noktadır. Sistem, eşleştirilen referans noktaları arasındaki toplam hatayı en aza indirecek $\mathbf{R}$ ve $\mathbf{t}$ değerlerini hesaplar.

Cerrahî alet nasıl takip edilir?

Optik sistemlerde ameliyathanedeki kızılötesi kameralar, aletlere ve hastaya bağlanan yansıtıcı işaretçileri izler. Elektromanyetik sistemlerde ise küçük sensörler oluşturulan manyetik alan içindeki konumlarını bildirir.

Ölçülen alet ucu, kayıt dönüşümü kullanılarak görüntü üzerinde çizilir. Aşağıdaki Python örneği, homojen koordinatlarla basit bir dönüşümü gösterir:

import numpy as np

# Alet ucunun takip sistemi tarafından ölçülen konumu
alet_ucu = np.array([12.0, 35.0, 80.0, 1.0])

# Döndürme ve ötelemeyi içeren 4x4 kayıt matrisi
kayit_matrisi = np.array([
    [1, 0, 0,  2],
    [0, 1, 0, -1],
    [0, 0, 1,  3],
    [0, 0, 0,  1]
])

goruntu_konumu = kayit_matrisi @ alet_ucu
print(goruntu_konumu[:3])

Gerçek sistemlerde matrisler sürekli güncellenir; filtreleme, kamera kalibrasyonu ve gecikme telafisi gibi ek işlemler uygulanır.

Hata nereden gelir?

Navigasyon ekranı mutlak gerçek değildir. Görüntüleme çözünürlüğü, yanlış işaretlenen referans noktaları, sensör gürültüsü ve hastanın hareketi hata oluşturabilir. Beyin cerrahisinde dokunun operasyon sırasında yer değiştirmesi, brain shift adı verilen önemli bir problemdir. Başlangıçta çekilen MR artık güncel anatomiyi tam yansıtmayabilir. Ameliyat içi ultrason veya yeni görüntüleme yöntemleri haritayı güncellemek için kullanılır.

Toplam hedef hatası kabaca bağımsız hata bileşenleriyle modellenebilir:

Bu nedenle sistemler ameliyat öncesinde doğrulanır ve cerrah, ekrandaki bilgiyi anatomik gözlemleriyle birlikte değerlendirir.

Cerrahî navigasyon cerrahın yerine karar veren bir otomatik pilot değildir; ona konum farkındalığı sağlayan gelişmiş bir yardımcıdır. Artırılmış gerçeklik, yapay zekâ ve ameliyat sırasında güncellenen 3B modeller geliştikçe bu dijital pusula daha da hassaslaşacaktır. Ancak son karar ve sorumluluk daima eğitimli sağlık ekibinde kalır.