``

Biyometrik eşleştirme nasıl çalışır?

Bir biyometrik sistem ham görüntüleri doğrudan karşılaştırmak yerine genellikle şablon adı verilen sayısal temsiller üretir. Parmak izinde çizgi sonları ve çatallanmalar; iriste ise doku frekansları, halkalar ve yerel desenler özellik olarak kullanılabilir.

Tipik işlem hattı şöyledir:

1. Sensörden görüntü alınır.
2. Gürültü azaltılır ve görüntü normalize edilir.
3. İlgi bölgesi belirlenir.
4. Ayırt edici özellikler çıkarılır.
5. Özellik vektörü kayıtlı şablonla karşılaştırılır.
6. Benzerlik belirlenen eşiği geçiyorsa eşleşme kabul edilir.

Benzerliği matematikle ölçmek

İki özellik vektörü arasındaki uzaklık için Öklid uzaklığı kullanılabilir. Kayıtlı şablon $x$, yeni örnek $y$ ise:

Uzaklık küçüldükçe örnekler birbirine daha çok benzer. Benzerlik puanını $[0,1]$ aralığına taşımak için basitçe şu dönüşüm uygulanabilir:

Karar kuralımız $s \geq t$ olabilir. Buradaki $t$ eşik değeridir. Eşiği yükseltmek güvenliği artırabilir ancak gerçek kullanıcıların reddedilmesine de yol açabilir.

Python ile basit prototip

Aşağıdaki kod gerçek görüntüler yerine sentetik biyometrik vektörler kullanır. Böylece kişisel veri toplamadan eşleştirme mekanizmasını deneyebiliriz.

import numpy as np

class BiometricMatcher:
    def __init__(self, threshold=0.80):
        self.threshold = threshold
        self.templates = {}

    def enroll(self, user_id, features):
        vector = np.asarray(features, dtype=float)
        norm = np.linalg.norm(vector)
        if norm == 0:
            raise ValueError("Sıfır vektörü kaydedilemez.")
        self.templates[user_id] = vector / norm

    def verify(self, user_id, sample):
        if user_id not in self.templates:
            return False, 0.0

        sample = np.asarray(sample, dtype=float)
        norm = np.linalg.norm(sample)
        if norm == 0:
            return False, 0.0

        sample = sample / norm
        template = self.templates[user_id]
        distance = np.linalg.norm(template - sample)
        score = 1 / (1 + distance)
        return score >= self.threshold, score

matcher = BiometricMatcher(threshold=0.80)
matcher.enroll("kullanici_42", [0.12, 0.77, 0.31, 0.55, 0.18])

accepted, score = matcher.verify(
    "kullanici_42",
    [0.11, 0.75, 0.34, 0.53, 0.20]
)
print(f"Kabul: {accepted}, skor: {score:.3f}")

enroll metodu özellik vektörünü normalize ederek saklar. verify ise yeni örnekle kayıtlı şablonun uzaklığını hesaplar. Normalizasyon, ölçüm ölçeğindeki farklılıkların etkisini azaltır; fakat gerçek sistemlerde dönüş, konum ve sensör kalitesi için çok daha gelişmiş işlemler gerekir.

Başarıyı nasıl değerlendirebiliriz?

Sistemi yalnızca “çalıştı” diyerek değerlendirmek yeterli değildir. FAR yetkisiz örneklerin kabul oranını, FRR ise gerçek kullanıcıların reddedilme oranını gösterir:

Eşiği farklı değerlerde deneyerek bu iki metriği karşılaştırabiliriz. Ayrıca farklı sensör koşulları, gürültü seviyeleri ve kullanıcı gruplarıyla test yapmak olası yanlılıkları ortaya çıkarır.

Son olarak biyometrik veri parola gibi kolayca değiştirilemez. Bu nedenle ham görüntü saklamak yerine şifrelenmiş veya iptal edilebilir şablonlar kullanılmalı; açık rıza, veri minimizasyonu, erişim kontrolü ve silme politikaları tasarımın merkezinde olmalıdır. Küçük dedektifimiz zeki olabilir, ama aynı zamanda mahremiyete saygılı olmak zorundadır.

``

Problemi sayılara dönüştürmek

28×28 piksellik gri tonlamalı bir rakam resmi, ağ açısından resim değil, 784 sayıdan oluşan bir vektördür. Her pikseli 255’e bölerek değerleri $[0,1]$ aralığına taşırız:

Çıkış katmanında ise 10 nöron bulunur. Örneğin doğru cevap 3 ise hedef vektörü $[0,0,0,1,0,0,0,0,0,0]$ olur. Buna one-hot kodlama denir.

Bir nöron önce ağırlıklı toplam hesaplar:

Ardından doğrusal olmayan sigmoid fonksiyonu uygulanır:

Doğrusal olmayan aktivasyon kullanılmazsa çok sayıda katman, matematiksel olarak tek bir doğrusal dönüşüme dönüşür. Başka bir deyişle ağ büyür, fakat zekâsı pek büyümez.

Ağı sıfırdan kodlamak

Aşağıdaki Python kodu matris kütüphanesi kullanmaz. Ağırlıkları üretmek için kendi basit sözde rastgele sayı üretecimizi bile yazıyoruz:

seed = 123456

def rnd():
    global seed
    seed = (1103515245 * seed + 12345) % (2 ** 31)
    return seed / (2 ** 31) - 0.5

def sigmoid(x):
    return 1.0 / (1.0 + 2.718281828 ** (-max(-30, min(30, x))))

def matrix(rows, cols):
    return [[rnd() * 0.1 for _ in range(cols)] for _ in range(rows)]

INPUT, HIDDEN, OUTPUT = 784, 64, 10
w1 = matrix(HIDDEN, INPUT)
b1 = [0.0] * HIDDEN
w2 = matrix(OUTPUT, HIDDEN)
b2 = [0.0] * OUTPUT

def forward(x):
    hidden = []
    for j in range(HIDDEN):
        z = b1[j] + sum(w1[j][i] * x[i] for i in range(INPUT))
        hidden.append(sigmoid(z))

    output = []
    for k in range(OUTPUT):
        z = b2[k] + sum(w2[k][j] * hidden[j] for j in range(HIDDEN))
        output.append(sigmoid(z))
    return hidden, output

forward fonksiyonu tahmin üretir; ancak öğrenme için hatayı ağırlıklara geri dağıtmamız gerekir. Ortalama karesel hata kullanırsak temel hedefimiz şudur:

def train(x, target, rate=0.1):
    hidden, output = forward(x)

    out_delta = [
        (output[k] - target[k]) * output[k] * (1 - output[k])
        for k in range(OUTPUT)
    ]

    hid_delta = []
    for j in range(HIDDEN):
        error = sum(out_delta[k] * w2[k][j] for k in range(OUTPUT))
        hid_delta.append(error * hidden[j] * (1 - hidden[j]))

    for k in range(OUTPUT):
        for j in range(HIDDEN):
            w2[k][j] -= rate * out_delta[k] * hidden[j]
        b2[k] -= rate * out_delta[k]

    for j in range(HIDDEN):
        for i in range(INPUT):
            w1[j][i] -= rate * hid_delta[j] * x[i]
        b1[j] -= rate * hid_delta[j]

Eğitim ve tahmin

Her eğitim resmi için piksel listesini normalize eder, doğru rakamın hedef değerini 1 yapar ve train fonksiyonunu çağırırız. Bu işlemin tüm veri üzerinde bir kez yapılmasına epoch denir. Eğitimden sonra tahmin, en yüksek çıkış değerinin indeksidir:

def predict(pixels):
    x = [p / 255.0 for p in pixels]
    _, scores = forward(x)
    return max(range(10), key=lambda i: scores[i])

Bu ağ modern modellerle yarışmayacaktır; fakat ileri yayılım, geri yayılım, gradyan inişi ve sınıflandırmanın nasıl birleştiğini açıkça gösterir. Sonraki adım olarak mini-batch eğitimi, ReLU, softmax ve çapraz entropi eklenebilir. Artık sinir ağı gizemli bir kara kutu değil; bolca döngü, türev ve sabırdan oluşan anlaşılır bir makinedir.

Temel fikir: Her damla bir parçacık

Parçacık sistemi, akışkanı çok sayıda küçük nesneyle temsil eder. Her parçacığın konumu $\vec{x}$, hızı $\vec{v}$, kütlesi $m$, ömrü ve türüne özgü özellikleri bulunur. Simülasyon döngüsünde önce kuvvetler hesaplanır, ardından ivme, hız ve konum güncellenir.

Newton’un ikinci yasası başlangıç noktamızdır:

Basit Euler integrasyonuyla güncelleme şöyledir:

Buradaki $\Delta t$, iki kare arasında geçen süredir. Sabit zaman adımı kullanmak simülasyonun farklı ekran yenileme hızlarında benzer davranmasını sağlar.

Su, ateş ve duman neden farklı görünür?

Aynı motoru kullanıp kuvvetleri ve görsel özellikleri değiştirerek üç farklı akışkan izlenimi oluşturabiliriz.

Su için yerçekimi, yüzey çarpışmaları ve komşu parçacıklar arasında itme kuvveti gerekir. Basitleştirilmiş basınç kuvveti, iki parçacık arasındaki uzaklık $r$ etkileşim yarıçapı $h$ değerinden küçükse uygulanabilir:

Burada $k$, akışkanın ne kadar sıkışmaz görüneceğini belirleyen katsayıdır. Bu yaklaşım gerçek SPH yönteminin sadeleştirilmiş hâlidir; bilimsel olarak kusursuz değildir ama oyun efektleri için hızlıdır.

Ateşte negatif yerçekimi benzeri bir kaldırma kuvveti kullanılır. Parçacık yaşlandıkça boyutu büyütülür, rengi sarıdan turuncuya geçirilir ve opaklığı azaltılır. Duman da yükselir fakat rastgele rüzgâr kuvvetleriyle yatayda daha fazla savrulur.

JavaScript ile çekirdek parçacık sınıfı

Aşağıdaki sınıf kuvvet biriktirme, Euler integrasyonu ve yaşam süresi yönetimini gerçekleştirir:

class Particle {
  constructor(x, y, type) {
    this.x = x;
    this.y = y;
    this.vx = (Math.random() - 0.5) * 40;
    this.vy = 0;
    this.ax = 0;
    this.ay = 0;
    this.age = 0;
    this.life = type === 'fire' ? 1.2 : 3;
    this.type = type;
  }

  applyForce(fx, fy, mass = 1) {
    this.ax += fx / mass;
    this.ay += fy / mass;
  }

  update(dt) {
    const gravity = this.type === 'water' ? 500 : -80;
    const turbulence = this.type === 'water'
      ? 0
      : (Math.random() - 0.5) * 100;

    this.applyForce(turbulence, gravity);
    this.vx += this.ax * dt;
    this.vy += this.ay * dt;
    this.x += this.vx * dt;
    this.y += this.vy * dt;
    this.ax = this.ay = 0;
    this.age += dt;
  }

  get alive() {
    return this.age < this.life;
  }
}

Her animasyon karesinde parçacıklara kuvvet uygulanır, update(dt) çağrılır ve ömrü dolanlar diziden çıkarılır. Su parçacıkları zemine çarptığında vy *= -0.3 ile sönümlü sekme uygulanabilir. Daha yapışkan bir sonuç için yatay hız da vx *= 0.9 ile azaltılabilir.

Performans ve görsel sihir

Parçacık sayısı yükseldiğinde bütün parçacık çiftlerini karşılaştırmak $O(n^2)$ maliyet oluşturur. Alanı ızgara hücrelerine bölerek yalnızca yakın hücrelerdeki komşuları test etmek maliyeti büyük ölçüde azaltır. Canvas üzerinde daire çizmek başlangıç için yeterlidir; WebGL kullanıldığında binlerce parçacık GPU üzerinde işlenebilir.

Son dokunuş fizik değil, sunumdur: suya yarı saydam katmanlar, ateşe additive blending, dumana yumuşak dokular ekleyin. Böylece basit denklemler, doğru renk ve hareket tercihleriyle şaşırtıcı derecede canlı bir akışkan gösterisine dönüşür.

Şifreleme ile hashleme aynı şey değildir

Şifreleme, doğru anahtara sahip olan kişinin veriyi geri çözebilmesi için tasarlanmıştır. Parolalarda ise uygulamanın özgün metni öğrenmesine gerek yoktur. Bu nedenle parola şifrelenmemeli, tek yönlü bir parola türetme fonksiyonuyla hashlenmelidir.

SHA-256 kriptografik olarak güçlü olsa da çok hızlıdır. Saldırganların saniyede milyonlarca parola tahmini yapabilmesi burada avantaj değil, felakettir. Argon2id gibi algoritmalar zaman ve bellek maliyetini yükselterek tahmin saldırılarını pahalılaştırır.

Bir parola $P$, rastgele salt $S$ ve maliyet parametreleri $m$, $t$, $p$ ile şöyle işlenebilir:

Salt, her kullanıcı için rastgele üretilir ve hash ile birlikte saklanabilir. Böylece aynı parolayı seçen iki kullanıcının hashleri farklı olur; hazır gökkuşağı tabloları da etkisizleşir.

Node.js ile güvenli parola işleme

Aşağıdaki örnek, argon2 paketiyle hash üretir ve giriş sırasında doğrulama yapar:

import argon2 from "argon2";

export async function createPasswordHash(password) {
  return argon2.hash(password, {
    type: argon2.argon2id,
    memoryCost: 19456,
    timeCost: 2,
    parallelism: 1
  });
}

export async function verifyPassword(storedHash, candidate) {
  return argon2.verify(storedHash, candidate);
}

Üretilen değer salt ve algoritma parametrelerini de taşır. Veritabanına parola yerine bu çıktı kaydedilir. Parametreler sunucunun kapasitesine göre ölçülmeli; giriş işlemini kabul edilebilir düzeyde tutarken toplu tahminleri yavaşlatmalıdır. Ayrıca giriş uç noktalarına hız sınırlama ve çok faktörlü kimlik doğrulama eklenmelidir.

XSS nasıl ortaya çıkar?

XSS, kullanıcı girdisinin HTML veya JavaScript olarak yorumlanmasıdır. Örneğin bir yorum doğrudan innerHTML ile sayfaya basılırsa saldırgan <script> etiketi ya da olay işleyicisi enjekte edebilir.

const message = document.querySelector("#message");
message.textContent = userInput;

textContent, girdiyi çalıştırılabilir HTML yerine metin olarak ekler. Zengin HTML kabul edilmesi gerçekten gerekiyorsa DOMPurify gibi bakımı sürdürülen bir sanitizasyon kütüphanesi kullanılmalıdır. URL, HTML niteliği, JavaScript ve CSS bağlamlarının farklı kodlama kuralları olduğu unutulmamalıdır.

Ek savunma olarak sunucu bir Content Security Policy gönderebilir:

Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self'

CSP tek başına açığı düzeltmez; başarılı bir enjeksiyonun etkisini sınırlar. Güvenli şablon motorları, HttpOnly, Secure ve SameSite çerezleri de savunmayı katmanlandırır. Özetle parolalarda Argon2id gibi yavaş hash fonksiyonları, XSS tarafında bağlama uygun kodlama, sanitizasyon ve CSP birlikte kullanılmalıdır. Güvenlik tek bir sihirli fonksiyon değil, birbirini tamamlayan kontrollere dayanan bir süreçtir.

REST nedir?

REST, yani Representational State Transfer, katı bir protokolden çok web servisleri tasarlamak için kullanılan mimari ilkeler bütünüdür. Temel fikir şudur: Sistemdeki kullanıcı, ürün veya sipariş gibi varlıklar birer kaynak olarak ele alınır. Her kaynak bir URL ile temsil edilir ve kaynak üzerinde yapılacak işlem HTTP metodu tarafından belirtilir.

Örneğin /api/products/12 adresi, kimliği 12 olan ürünü temsil edebilir. URL’nin urun-getir.php?id=12 gibi bir eylem anlatması yerine kaynağı tanımlaması REST yaklaşımına daha uygundur.

REST servislerinin durumsuz olması beklenir. Sunucu, önceki isteği hatırlamak zorunda kalmamalıdır; ihtiyaç duyulan kimlik doğrulama ve parametreler her istekte taşınmalıdır. Böylece istek sayısı $n$ olduğunda işlemler birbirinden bağımsız kalır ve sistemin yatay olarak ölçeklenmesi kolaylaşır.

JSON neden kullanılır?

JSON, anahtar-değer çiftlerinden ve dizilerden oluşan hafif bir veri formatıdır. PHP dizileri, JavaScript nesneleri ve pek çok dildeki sözlük yapılarıyla rahatça eşleştirilebilir.

{
  "id": 12,
  "name": "Mekanik Klavye",
  "price": 2499.90,
  "inStock": true
}

JSON yalnızca veriyi taşır; görünüm kararını istemciye bırakır. Aynı yanıt mobil uygulamada kart, yönetim panelinde tablo, başka bir sistemde ise rapor satırı olarak gösterilebilir. Yaklaşık yanıt boyutu $B$ ve saniyedeki istek sayısı $R$ ise ağ yükü kabaca $B \times R$ ile ifade edilebilir. Gereksiz alanları kaldırmak bu nedenle önemlidir.

PHP ile basit bir API uç noktası

Aşağıdaki örnek, PDO kullanarak veritabanından ürünleri okur ve JSON yanıtı döndürür:

<?php
header('Content-Type: application/json; charset=utf-8');

$pdo = new PDO(
    'mysql:host=localhost;dbname=shop;charset=utf8mb4',
    'api_user',
    'secret',
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);

try {
    $stmt = $pdo->query(
        'SELECT id, name, price FROM products ORDER BY id DESC'
    );

    $products = $stmt->fetchAll(PDO::FETCH_ASSOC);

    http_response_code(200);
    echo json_encode([
        'success' => true,
        'data' => $products,
        'count' => count($products)
    ], JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION);
} catch (Throwable $error) {
    http_response_code(500);
    echo json_encode([
        'success' => false,
        'error' => 'Sunucu hatası oluştu.'
    ], JSON_UNESCAPED_UNICODE);
}

Content-Type başlığı istemciye yanıtın JSON olduğunu bildirir. json_encode() PHP dizisini JSON metnine dönüştürür. Hata oluştuğunda ayrıntılı veritabanı mesajını dışarı vermemek ise tablo adları veya bağlantı bilgileri gibi hassas ayrıntıların sızmasını önler.

İstek gövdesini okumak

POST ve PATCH isteklerinde JSON verisi php://input üzerinden alınabilir:

$body = file_get_contents('php://input');
$input = json_decode($body, true);

if (!is_array($input) || empty($input['name'])) {
    http_response_code(422);
    echo json_encode(['error' => 'name alanı zorunludur.']);
    exit;
}

Burada 422 Unprocessable Content, JSON okunabilse bile doğrulama kurallarının sağlanmadığını anlatır. Geçersiz JSON için 400 Bad Request, bulunamayan kaynak için 404 Not Found kullanılmalıdır. Her hataya 200 dönmek, yangın alarmını ne olursa olsun yeşil yakmaya benzer!

Son olarak API’yi HTTPS, token tabanlı kimlik doğrulama, giriş doğrulama, hız sınırlama ve sürümleme ile güçlendirin. /api/v1/products gibi sürümlü adresler, gelecekte yapılacak değişikliklerin mevcut istemcileri bozmamasına yardımcı olur. Böylece PHP uygulamanız bir web sayfası üreticisinden, farklı sistemlerin güvenle konuşabildiği gerçek bir veri köprüsüne dönüşür.

``

Ray tracing nasıl çalışır?

Gerçek dünyada fotonlar ışık kaynağından çıkar ve kameraya ulaşır. Ancak milyarlarca fotonu rastgele takip etmek verimsizdir. Klasik ray tracing bunun tersini yapar: Her piksel için kameradan sahneye bir birincil ışın gönderir. Işın bir yüzeye çarparsa en yakın kesişim noktası bulunur; ardından ışık, gölge ve yansıma hesaplanır.

Bir ışın parametrik olarak şöyle gösterilir:

Burada $O$ ışının başlangıç noktası, $D$ normalize edilmiş yönü, $t$ ise ışın üzerindeki mesafedir. $t > 0$ koşulunu sağlayan en küçük değer, kameraya en yakın görünür yüzeyi verir.

Küreyle kesişim

Merkezi $C$, yarıçapı $r$ olan kürenin denklemi $\lVert P-C\rVert^2=r^2$ biçimindedir. $P=R(t)$ yerleştirildiğinde ikinci dereceden denklem elde edilir:

Diskriminant $\Delta=b^2-4ac$ negatifse kesişim yoktur. Pozitifse iki çözümden en küçük pozitif olanı seçilir.

import numpy as np

def normalize(v):
    return v / np.linalg.norm(v)

def hit_sphere(origin, direction, center, radius):
    oc = origin - center
    a = np.dot(direction, direction)
    b = 2.0 * np.dot(oc, direction)
    c = np.dot(oc, oc) - radius * radius
    delta = b * b - 4 * a * c
    if delta < 0:
        return None

    roots = [(-b - np.sqrt(delta)) / (2 * a),
             (-b + np.sqrt(delta)) / (2 * a)]
    valid = [t for t in roots if t > 1e-4]
    return min(valid) if valid else None

Küçük 1e-4 eşiği, ışının çıktığı yüzeye yeniden çarpmasını önler. Bu sorun render dünyasında shadow acne olarak bilinir; görüntünüz sivilce çıkarırsa matematiği suçlayabilirsiniz.

Aydınlatma, gölge ve yansıma

Mat Lambert yüzeylerde parlaklık, normal $N$ ile ışık yönü $L$ arasındaki açıya bağlıdır:

Noktasal ışığın şiddeti ayrıca uzaklığın karesiyle azalır: $I_L=P/(4\pi d^2)$. Böylece uzaktaki nesneler fiziksel olarak daha az aydınlanır. Kesişim noktasından ışığa gönderilen gölge ışını başka bir nesneye çarparsa doğrudan aydınlatma sıfırlanır.

Mükemmel ayna yansımasının yönü ise şöyledir:

def reflect(direction, normal):
    return normalize(direction - 2 * np.dot(direction, normal) * normal)

def shade(point, normal, light_pos, light_power, blocked):
    to_light = light_pos - point
    distance = np.linalg.norm(to_light)
    light_dir = normalize(to_light)
    if blocked or np.dot(normal, light_dir) <= 0:
        return 0.0
    return light_power * np.dot(normal, light_dir) / (4 * np.pi * distance**2)

blocked değeri, gölge ışınının ışığa ulaşmadan önce nesne bulup bulmadığını belirtir. Yansıma için reflect yönünde yeni bir ışın gönderilir ve dönen renk yüzeyin yansıtıcılığıyla çarpılır.

Render döngüsünde her pikseli kamera düzlemindeki bir koordinata dönüştürün, ışını normalize edin ve trace(ray, depth) fonksiyonunu çağırın. Fonksiyon en yakın nesneyi bulmalı, yerel rengi hesaplamalı ve derinlik sınırı aşılmadıysa yansıma ışınını özyinelemeli izlemelidir. Üç veya dört sekme başlangıç için yeterlidir.

Bu temel motor; üçgen kesişimi, BVH hızlandırma yapısı, kırılma, Fresnel etkisi ve Monte Carlo örneklemesi eklenerek gerçek bir path tracer’a dönüştürülebilir. İlk görüntü yavaş üretilebilir, fakat kendi yazdığınız aynalı kürenin başka bir küreyi yansıttığını görmek beklemeye kesinlikle değer.

``

Açılış zinciri nasıl çalışır?

BIOS tabanlı klasik bir sistemde ilk sektör, yani 512 baytlık boot sektörü, bellekte 0x7C00 adresine yüklenir. Son iki baytın 0x55AA olması BIOS’a sektörün önyüklenebilir olduğunu bildirir. Bootloader’ın görevi çekirdeği diskten belleğe taşımak, uygun işlemci kipini hazırlamak ve denetimi çekirdeğin giriş noktasına bırakmaktır.

Boot sektörünün sonunu hazırlayan minimal NASM kodu şöyledir:

bits 16
org 0x7C00

cli                 ; Hazırlık sırasında kesmeleri kapat
xor ax, ax
mov ds, ax
mov ss, ax
mov sp, 0x7C00      ; Geçici yığın oluştur

hang:
    hlt
    jmp hang

times 510-($-$$) db 0
dw 0xAA55

Buradaki $ mevcut adresi, $$ ise bölümün başlangıcını gösterir. Dolgu miktarı matematiksel olarak $510-(\text{mevcut konum}-\text{başlangıç})$ biçiminde hesaplanır.

Korumalı kip ve çekirdeğe geçiş

32-bit korumalı kip için önce Global Descriptor Table oluşturulur. GDT, kod ve veri segmentlerinin taban adresi, sınırı ve erişim haklarını tanımlar. Ardından CR0 yazmacındaki PE biti etkinleştirilir:

cli
lgdt [gdt_descriptor]
mov eax, cr0
or eax, 1
mov cr0, eax
jmp 0x08:protected_mode

Uzak atlama, işlemcinin komut kuyruğunu temizler ve yeni kod segmentini yükler. Çekirdeği C ile yazmak geliştirmeyi kolaylaştırır; ancak standart kütüphane kullanılamaz. Bu nedenle memcpy, memset ve ekran çıktısı gibi araçları kendimiz üretiriz.

volatile unsigned short *vga = (unsigned short *)0xB8000;

void put_char(char c, int position) {
    vga[position] = (0x0F << 8) | c;
}

void kernel_main(void) {
    put_char('K', 0); /* VGA metin belleğine doğrudan yazar */
    for (;;) __asm__ volatile("hlt");
}

Kesme olmadan çoklu görev olmaz

Çekirdeğin düzenli aralıklarla kontrolü geri alması için PIT zamanlayıcısı ve Interrupt Descriptor Table gerekir. PIT frekansı yaklaşık $1{,}193{,}182$ Hz’dir. İstenen kesme frekansı $f$ ise gönderilecek bölen

olarak hesaplanır. Örneğin 100 Hz için yaklaşık 11931 kullanılır. Her zamanlayıcı kesmesinde çalışan görevin yazmaçları saklanır ve sıradaki görevin bağlamı yüklenir.

typedef struct {
    unsigned int esp;
    unsigned int id;
    int active;
} task_t;

int current = 0;
task_t tasks[2];

void schedule(void) {
    current = (current + 1) % 2;
    switch_stack(tasks[current].esp);
}

Bu basit yöntem round-robin zamanlamadır. Her görev eşit zaman dilimi alır; $n$ görev ve $T$ uzunluğunda dilim için aynı göreve yaklaşık $nT$ sonra dönülür. Gerçek bir bağlam değişiminde ESP dışında genel yazmaçlar, bayraklar ve gerekirse adres uzayı da korunmalıdır.

Projeyi QEMU üzerinde çalıştırmak, fiziksel donanımı yanlışlıkla kilitlemeden seri port günlüklerini ve işlemci durumunu incelemeyi sağlar. İlk hedefiniz ekrana iki görevin dönüşümlü karakter yazması olabilir. Bu küçük başarı, modern işletim sistemlerinin arkasındaki görünmez orkestrayı elle kurduğunuz anlamına gelir.

Turing tamlık ne anlama gelir?

Bir dil, yeterli zaman ve bellek verildiğinde herhangi bir hesaplanabilir algoritmayı ifade edebiliyorsa Turing tam kabul edilir. Pratik bir dil için temel gereksinimler şunlardır:

Özellikle while döngüsü ve teorik olarak sınırsız büyüyebilen sayılar sayesinde dilimiz, bir sayaç makinesini simüle edebilir. Örneğin bir sayıyı tekrar tekrar azaltmak şu geçişi oluşturur:

Koşullu sıçramalarla birleşen bu işlem, genel hesaplama modellerini ifade etmek için yeterlidir. Gerçek bilgisayarların belleği elbette sonludur; Turing tamlık idealize edilmiş sınırsız kaynak varsayımına dayanır.

Dilin söz dizimi

MiniLang ile faktöriyel hesabı şöyle görünebilir:

let n = 5;
let result = 1;
while (n > 1) {
    result = result * n;
    n = n - 1;
}
print result;

Burada amaçlanan sonuç $5! = 5\times4\times3\times2\times1 = 120$ değeridir. Şimdi kaynak kodun yorumlayıcıdan geçerken uğradığı üç durağa bakalım.

1. Lexer: Metni jetonlara ayırmak

Lexer, karakterleri NUMBER, IDENT, PLUS gibi tokenlara dönüştürür. Böylece parser tek tek karakterlerle boğuşmaz.

import re

TOKEN_RE = re.compile(
    r'(?P<NUMBER>\d+)|(?P<IDENT>[A-Za-z_]\w*)|'
    r'(?P<OP>==|>|[+\-*/=;(){}])|(?P<SPACE>\s+)'
)

def lex(source):
    tokens = []
    for match in TOKEN_RE.finditer(source):
        kind, value = match.lastgroup, match.group()
        if kind != 'SPACE':
            tokens.append((kind, value))
    return tokens

Bu fonksiyon boşlukları atlar, sayıları ve isimleri tanır. Sağlam bir sürüm ayrıca eşleşmeyen karakterlerin konumunu bildirerek anlaşılır hata mesajları üretmelidir.

2. Parser: Tokenlardan anlamlı bir ağaç kurmak

Parser, token dizisini soyut sözdizimi ağacına, yani AST’ye çevirir. Basit gramerimizin özeti şöyledir:

statement  -> 'let' IDENT '=' expression ';'
            | IDENT '=' expression ';'
            | 'while' '(' expression ')' block
            | 'print' expression ';'
expression -> comparison
comparison -> term ('>' term)*
term       -> factor (('+' | '-') factor)*
factor     -> primary (('*' | '/') primary)*

Öncelik katmanları önemlidir: 2 + 3 * 4, $(2+3)\times4$ değil, $2+(3\times4)=14$ biçiminde ayrıştırılmalıdır. Recursive descent yaklaşımında her gramer kuralı bir Python fonksiyonuna dönüştürülür. Örneğin toplama katmanı:

def parse_term(self):
    node = self.parse_factor()
    while self.peek_value() in ('+', '-'):
        operator = self.advance()[1]
        right = self.parse_factor()
        node = ('binary', operator, node, right)
    return node

Üretilen tuple, operatörü ve iki alt ifadeyi taşıyan küçük bir AST düğümüdür.

3. Yorumlayıcı: Ağacı çalıştırmak

Yorumlayıcı değişkenleri bir sözlükte tutar ve AST düğümlerini değerlendirir:

def evaluate(node, env):
    kind = node[0]
    if kind == 'number':
        return int(node[1])
    if kind == 'variable':
        return env[node[1]]
    if kind == 'binary':
        _, op, left, right = node
        a, b = evaluate(left, env), evaluate(right, env)
        operations = {
            '+': lambda: a + b, '-': lambda: a - b,
            '*': lambda: a * b, '/': lambda: a // b,
            '>': lambda: int(a > b)
        }
        return operations[op]()

while düğümü için koşul sıfır olmadığı sürece gövde tekrar yorumlanır. Atama düğümü de env[name] = evaluate(expression, env) işlemini yapar. Böylece lexer harfleri tokenlara, parser tokenları ağaca, yorumlayıcı ise ağacı davranışa dönüştürür. Birkaç hata mesajı, fonksiyon desteği ve REPL eklediğinizde MiniLang artık oyuncak görünümündeki ciddi bir hesaplama laboratuvarıdır.

Sürü zekâsı nedir?

Sürü zekâsı, merkezi yönetim olmadan çalışan çok sayıda basit ajanın yerel etkileşimlerinden doğan kolektif davranıştır. Bir kuş, bütün sürünün konumunu hesaplamaz; yalnızca yakınındaki komşularını gözlemler. Bu yaklaşım robot koordinasyonu, trafik modelleme, oyun yapay zekâsı ve optimizasyon gibi alanlarda kullanılır.

Craig Reynolds tarafından geliştirilen Boids modeli, her kuşu bağımsız bir ajan olarak ele alır. Ajanın konumu $p_i$, hızı ise $v_i$ olsun. Her simülasyon adımında hareket yaklaşık olarak şöyle güncellenir:

Buradaki $S_i$ ayrılma, $A_i$ hizalanma ve $C_i$ bütünleşme kuvvetidir. $w_s$, $w_a$ ve $w_c$ katsayıları davranışların etkisini belirler.

Bu kuralların hiçbiri tek başına gerçekçi bir sürü oluşturmaz. Ayrılma fazla güçlü olursa ajanlar birbirinden kaçar; bütünleşme baskın olursa ekranın ortasında sıkışmış bir top oluşur. Eğlence, katsayılarla oynayıp düzen ile kaos arasındaki dengeyi bulmaktadır.

Python ile hareket çekirdeği

Aşağıdaki sınıf, bir ajanın komşularına bakarak üç temel kuvveti hesaplar. NumPy vektör işlemlerini kolaylaştırır:

import numpy as np

class Boid:
    def __init__(self, position, velocity):
        self.position = np.array(position, dtype=float)
        self.velocity = np.array(velocity, dtype=float)

    def update(self, flock, radius=60):
        neighbors = [b for b in flock
                     if b is not self and
                     np.linalg.norm(b.position - self.position) < radius]

        if not neighbors:
            self.position += self.velocity
            return

        center = np.mean([b.position for b in neighbors], axis=0)
        average_velocity = np.mean([b.velocity for b in neighbors], axis=0)

        cohesion = (center - self.position) * 0.002
        alignment = (average_velocity - self.velocity) * 0.05
        separation = np.zeros(2)

        for other in neighbors:
            difference = self.position - other.position
            distance = np.linalg.norm(difference)
            if 0 < distance < 20:
                separation += difference / distance

        self.velocity += cohesion + alignment + separation * 0.08

        speed = np.linalg.norm(self.velocity)
        if speed > 4:
            self.velocity = self.velocity / speed * 4

        self.position += self.velocity

neighbors listesi algı yarıçapındaki ajanları seçer. Bütünleşme komşuların geometrik merkezini, hizalanma ortalama hızını hedefler. Ayrılma ise mesafe azaldıkça ajanı ters yönde iter. Hız sınırı koymak önemlidir; aksi hâlde kuvvetler birikerek kuşları roket hızına ulaştırabilir.

Simülasyonu canlandırmak

Pygame, ajanları ekranda göstermek için kullanılabilir. Her karede tüm ajanlar güncellenir, ekran sınırını aşanlar karşı taraftan çıkarılır ve küçük daireler çizilir:

for boid in flock:
    boid.update(flock)
    boid.position %= [width, height]
    pygame.draw.circle(screen, (80, 210, 255),
                       boid.position.astype(int), 4)

Kuş görünümü için hız yönünde dönen üçgenler, balık görünümü için kuyruk animasyonu eklenebilir. Fare imlecini bir avcı olarak tanımlayıp yakındaki ajanlara kaçış kuvveti uygulamak da sürünün aniden yarılması gibi etkileyici davranışlar üretir.

Deney fikirleri

Ajan sayısını, algı yarıçapını ve kural ağırlıklarını çalışma sırasında değiştirin. Sonuçları yalnızca görsel olarak değil, ortalama komşu mesafesi ve yön uyumu gibi ölçülerle de inceleyin. Örneğin yön uyumu, normalize edilmiş hızların ortalamasıyla $0$ ile $1$ arasında ölçülebilir. Basit yerel kararların küresel düzeyde nasıl örgütlendiğini görmek, bu projeyi hem öğretici hem de hipnotik derecede eğlenceli yapar.

Turing Testi ve zekânın ölçülmesi

Alan Turing, 1950 tarihli Computing Machinery and Intelligence makalesinde düşünmenin kesin bir tanımını yapmak yerine davranışsal bir ölçüt önerdi. Taklit Oyunu olarak adlandırılan ve sonradan Turing Testi diye bilinen düzende bir insan değerlendirici, yazılı mesajlarla insan ve makineyle konuşur. Değerlendirici hangisinin makine olduğunu güvenilir biçimde ayırt edemiyorsa makine, insan benzeri dil davranışı sergilemiş kabul edilir.

Test önemli bir felsefi dönüşüm yarattı: İç dünyası gözlemlenemeyen bir sistemin zekâsı, davranışı üzerinden değerlendirilebilirdi. Ancak test; bilinç, doğruluk veya gerçek anlama garantisi vermez. Son derece ikna edici biçimde yanlış konuşan bir program testi geçebilir. Günümüzün büyük dil modelleri etrafındaki tartışmalar da tam olarak bu noktaya dokunur.

Sembolik yapay zekâ dönemi

“Yapay zekâ” terimi, 1956 Dartmouth çalıştayında akademik kimlik kazandı. İlk araştırmacılar zekânın semboller ve açık kurallar aracılığıyla modellenebileceğine inanıyordu. Bu yaklaşımda bilgi, mantıksal ifadeler şeklinde temsil edilir:

Bir uzman sistem, mevcut olgulara kurallar uygulayarak yeni sonuçlar üretir. Örneğin basit bir teşhis mekanizması şöyle yazılabilir:

belirtiler = {"ates", "oksuruk"}

if {"ates", "oksuruk"}.issubset(belirtiler):
    sonuc = "Solunum yolu enfeksiyonu araştırılmalı"
else:
    sonuc = "Yeterli kural eşleşmesi yok"

print(sonuc)

Bu kod, sembolik yaklaşımın şeffaflığını gösterir: Sonucun hangi koşuldan çıktığı bellidir. Fakat gerçek dünya istisnalarla doludur. Binlerce kuralı elle yazmak, çelişkileri çözmek ve belirsizliği temsil etmek zorlaşır. Bu darboğazlar ile sınırlı donanım, 1970’ler ve 1980’lerin sonlarında “yapay zekâ kışı” denilen yatırım ve ilgi düşüşlerine katkıda bulundu.

Veriden öğrenmeye geçiş

Modern istatistiksel yaklaşımda geliştirici bütün kuralları yazmaz; model, örneklerden örüntü öğrenir. Amaç çoğu zaman belirli girdiler altında en olası çıktıyı bulmaktır:

Bu dönüşümü daha fazla dijital veri, güçlü işlemciler, internet ve gelişmiş optimizasyon yöntemleri hızlandırdı. 1990’larda olasılıksal modeller ve destek vektör makineleri öne çıkarken, 2010’larda derin öğrenme görüntü ve konuşma alanlarında büyük sıçramalar sağladı. 2012’de AlexNet’in başarısı, GPU destekli sinir ağlarının gücünü görünür hâle getirdi.

Transformer çağı ve üretken yapay zekâ

2017’de tanıtılan Transformer mimarisi, dizilerdeki öğelerin birbirleriyle ilişkisini dikkat mekanizması üzerinden hesapladı. Basitleştirilmiş dikkat formülü şöyledir:

Bu yapı paralel eğitime elverişli olduğu için devasa metin koleksiyonlarından dil örüntülerinin öğrenilmesini kolaylaştırdı. Büyük dil modelleri bir sonraki belirtecin olasılığını tahmin ederek eğitilse de ölçek büyüdükçe özetleme, kod üretme ve soru yanıtlama gibi yetenekler sergiledi.

Yine de günümüz yapay zekâsı kusursuz değildir: Yanlış bilgi üretebilir, eğitim verilerindeki önyargıları yansıtabilir ve yüksek enerji tüketebilir. Alanın geleceği muhtemelen sembolik yöntemlerle istatistiksel öğrenmenin rakip değil, tamamlayıcı kabul edildiği hibrit sistemlerde yatıyor. Kısacası Turing’in sorusu hâlâ masada; yalnızca makinelerin verdiği cevaplar artık çok daha etkileyici.