Go’nun concurrency yaklaşımını anlamanın ilk adımı şu ayrımı netleştirmektir: Concurrency aynı zaman aralığında birden fazla işle ilerleyebilme yeteneğidir; parallelism ise gerçekten aynı anda, farklı CPU çekirdeklerinde çalışmaktır. Yani concurrency bir tasarım modeli, parallelism ise donanımın sunduğu fiziksel imkândır.

Basitçe ifade edersek:

Go runtime içinde ünlü M:P:G modeli çalışır. Burada G goroutine’i, M işletim sistemi thread’ini, P ise işlemci bağlamını temsil eder. Kabaca ilişkiyi şöyle düşünebiliriz: $G \rightarrow P \rightarrow M$. Eğer $N$ adet goroutine’iniz ve $P$ adet işlemci bağlamınız varsa, Go scheduler bu goroutine’leri uygun thread’lere dağıtarak verimli çalıştırır. Bu yüzden binlerce goroutine açmak çoğu senaryoda binlerce OS thread açmaktan çok daha ucuzdur.

Goroutine başlatmak şaşırtıcı derecede kolaydır:

package main

import (
    "fmt"
    "time"
)

func sendEmail(user string) {
    time.Sleep(500 * time.Millisecond)
    fmt.Println("E-posta gönderildi:", user)
}

func main() {
    users := []string{"ada", "linus", "grace"}

    for _, user := range users {
        go sendEmail(user)
    }

    time.Sleep(1 * time.Second)
}

Bu örnekte her kullanıcı için ayrı bir goroutine başlatılır. sendEmail fonksiyonu bloklansa bile ana akış diğer işleri başlatmaya devam eder. Ancak gerçek projelerde time.Sleep ile beklemek pek yakışıklı değildir; bu, restoranda garsona “yemekler herhalde gelir” deyip göz kararı beklemek gibidir.

Daha kontrollü bir yapı için channel kullanırız. Channel’lar goroutine’ler arasında güvenli veri aktarımı sağlar. Go’nun meşhur sözü burada devreye girer: Belleği paylaşarak iletişim kurma; iletişim kurarak belleği paylaş.

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, jobs <-chan string, results chan<- string) {
    for {
        select {
        case <-ctx.Done():
            return
        case job, ok := <-jobs:
            if !ok {
                return
            }
            time.Sleep(300 * time.Millisecond)
            results <- fmt.Sprintf("İş tamamlandı: %s", job)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    jobs := make(chan string)
    results := make(chan string)

    for i := 0; i < 3; i++ {
        go worker(ctx, jobs, results)
    }

    go func() {
        defer close(jobs)
        for i := 1; i <= 5; i++ {
            jobs <- fmt.Sprintf("görev-%d", i)
        }
    }()

    for i := 1; i <= 5; i++ {
        fmt.Println(<-results)
    }
}

Burada üç worker goroutine’i aynı jobs kanalından görev alır ve sonuçları results kanalına gönderir. context ise servis kapanışı, timeout veya iptal sinyalleri için temiz bir kontrol mekanizması sunar. Bu yapı, e-posta gönderimi, görsel işleme, log toplama veya webhook tüketimi gibi arka plan servislerinde sıkça kullanılır.

Performans açısından bakarsak, goroutine’lerin başlangıç stack’i küçüktür ve ihtiyaç oldukça büyür. Klasik thread’lerde stack maliyeti megabaytlarla ifade edilebilirken, goroutine’lerde başlangıç maliyeti kilobayt seviyesindedir. Teorik olarak toplam bellek tüketimini şöyle düşünebiliriz: $ToplamBellek \approx n \times s$. Burada $n$ görev sayısı, $s$ ise görev başına stack maliyetidir. $s$ küçüldükçe aynı makinede daha fazla eşzamanlı iş yönetebilirsiniz.

Tabii goroutine açmak bedava değildir; sadece ucuzdur. Sonsuz sayıda goroutine başlatmak, mutfağa sınırsız sipariş yollayıp aşçıdan mucize beklemek gibidir. Bu nedenle worker pool, rate limit, context cancellation ve buffer’lı channel gibi tekniklerle sisteminize sınır koymalısınız.

Sonuç olarak Go’nun concurrency mimarisi, basit sözdizimiyle güçlü bir runtime mühendisliğini birleştirir. Goroutine’ler sayesinde arka plan servisleri hem okunabilir hem de yüksek verimli olabilir. Eğer kuyruk tüketen, API çağrılarını paralelleştiren veya binlerce bağlantıyı yöneten bir servis yazıyorsanız, Go size “thread açalım mı?” diye sormaz; zarifçe go anahtar kelimesini uzatır ve “hadi işi bölelim” der.

Teorik olarak sistemi şu denklemle düşünebiliriz: $IDE = Editör + LSP + DAP + TaskRunner + Eklenti$. Burada LSP, Language Server Protocol yani dil sunucusu protokolüdür. Kod tamamlama, sembole gitme, hata işaretleme gibi özellikleri sağlar. DAP, Debug Adapter Protocol ile hata ayıklama dünyasını standartlaştırır. TaskRunner ise derleme, test, lint ve deploy gibi komutları yönetir.

Çoklu dil çalışma alanında önemli kavramlardan biri bağımlılık grafiğidir. Diyelim ki önyüz projesi API tiplerini otomatik üretilen bir dosyadan alıyor. Bu durumda $frontend \rightarrow generatedTypes \rightarrow backendSchema$ şeklinde bir ilişki oluşur. IDE bu ilişkiyi görevlerle temsil ederse, geliştirici tek tuşla önce şemayı güncelleyip sonra önyüzü başlatabilir.

type Task = { name: string; run: () => Promise<void> };

const tasks: Task[] = [
  { name: 'api:generate', run: async () => console.log('OpenAPI tipleri üretildi') },
  { name: 'frontend:lint', run: async () => console.log('Önyüz kontrol edildi') },
  { name: 'frontend:dev', run: async () => console.log('Vite geliştirme sunucusu açıldı') }
];

async function runPipeline() {
  for (const task of tasks) {
    console.log('Çalışıyor:', task.name);
    await task.run();
  }
}

runPipeline();

Bu kod basit bir görev hattını temsil eder. Gerçek IDE içinde bu yapı çoğu zaman launch, tasks veya workspace ayarlarıyla tanımlanır. Ama mantık aynıdır: görevler sıraya alınır, çıktılar terminalde toplanır, hata olursa zincir durdurulur ya da kullanıcı uyarılır.

Gelişmiş IDE’lerde bu entegrasyonun eğlenceli kısmı otomasyondur. Örneğin dosya kaydedildiğinde formatter çalışır, testler tetiklenir, tip dosyaları yenilenir ve önyüz sıcak yenileme ile güncellenir. Kullanıcı sadece kod yazar; IDE sahne arkasında küçük bir robot ordusu gibi çalışır. Ancak bu robot ordusunun kontrolden çıkmaması için net kurallar gerekir: görev adları anlamlı olmalı, ortam değişkenleri belgelenmeli, her dilin bağımlılık yönetimi izole edilmelidir.

Pratikte iyi bir çoklu dil IDE mimarisi için üç öneri öne çıkar. Birincisi, her teknolojinin kendi doğal aracını kullanın; Python için venv, Node için pnpm veya npm, Java için Maven gibi. İkincisi, ortak akışları IDE görevlerine bağlayın. Üçüncüsü, debug yapılandırmalarını ekip içinde paylaşın. Böylece yeni gelen geliştirici projeyi klonladığında sadece kodu değil, çalışma ritüelini de devralır.

Sonuç olarak çoklu dil mimarisi, IDE’yi pasif bir editörden aktif bir geliştirme merkezine dönüştürür. Arka plandaki otomasyon betikleri, önyüz projeleri ve servisler aynı sahnede buluştuğunda üretkenlik artar. Doğru kurgulanmış bir workspace, geliştiriciye şu hissi verir: Farklı diller konuşan bir ekip var, ama hepsi aynı orkestrada çalıyor.

Bu tür uygulamaların temelinde üç kavram vardır: uyaran, tepki ve ölçüm. Uyaran; ekranda gösterilen soru, görsel, renk ya da görevdir. Tepki; kullanıcının tıklaması, yazması, sürüklemesi veya beklemesidir. Ölçüm ise bu tepkinin zamana, doğruluğa veya tutarlılığa göre sayısallaştırılmasıdır. Basit bir modelle kullanıcı davranış skoru şöyle düşünülebilir: $S = w_1 x_1 + w_2 x_2 + w_3 x_3$. Burada $x$ değerleri davranış ölçümlerini, $w$ değerleri ise bu ölçümlerin ağırlıklarını temsil eder.

Daha genel biçimde, bir test puanını şu şekilde ifade edebiliriz:

Bu formül bize şunu söyler: Her cevap aynı önemde olmak zorunda değildir. Örneğin bir hafıza testinde doğru cevap kadar cevap verme süresi de anlamlı olabilir.

Dinamik DOM manipülasyonu burada sahnenin ışıkçısı gibidir. Kullanıcı bir soruya cevap verdiğinde yeni soru gösterilir, renkler değişir, sonuç ekranı oluşturulur veya zorluk seviyesi artırılır. Böylece sayfa yenilenmeden akıcı bir deney tasarlanır.

Aşağıdaki örnek, basit bir dikkat testi mantığını gösterir. Kullanıcıdan ekranda beliren hedef renge mümkün olduğunca hızlı tıklaması istenir:

const app = document.querySelector('#app');
const colors = ['red', 'blue', 'green', 'purple'];
let startTime = 0;
let results = [];

function newRound() {
  const target = colors[Math.floor(Math.random() * colors.length)];
  startTime = performance.now();

  app.innerHTML = `
    <p>Hedef renk: <strong>${target}</strong></p>
    <div class='grid'>
      ${colors.map(color => `<button class='box' data-color='${color}' style='background:${color}'></button>`).join('')}
    </div>
  `;

  document.querySelectorAll('.box').forEach(button => {
    button.addEventListener('click', () => {
      const reaction = performance.now() - startTime;
      const correct = button.dataset.color === target;
      results.push({ reaction, correct });
      showFeedback(correct, reaction);
    });
  });
}

function showFeedback(correct, reaction) {
  app.innerHTML = `
    <p>${correct ? 'Doğru!' : 'Yanlış!'}</p>
    <p>Tepki süresi: ${Math.round(reaction)} ms</p>
    <button id='next'>Yeni Tur</button>
  `;
  document.querySelector('#next').addEventListener('click', newRound);
}

newRound();

Bu kodda performance.now() milisaniye hassasiyetinde zaman ölçer. Kullanıcının doğru renge tıklayıp tıklamadığı dataset üzerinden kontrol edilir. DOM, her turda yeniden çizilerek testin akışı yönetilir.

Sosyolojik veya psikolojik deneylerde en kritik konu etik tasarımdır. Kullanıcıdan açık rıza alınmalı, veriler anonimleştirilmeli ve sonuçlar kesin tanı gibi sunulmamalıdır. “Zekan 142 çıktı” demek yerine “Bu mini testte hızlı örüntü tanıma eğilimi gösterdin” demek çok daha sağlıklıdır.

Sonuç ekranı da davranış analizi kadar önemlidir. Kullanıcıya grafikler, ortalama tepki süresi ve doğru cevap oranı gösterilebilir. Örneğin doğruluk oranı $D = doğru / toplam$ formülüyle hesaplanır. Bu basit oran, anlaşılır bir geri bildirim üretir.

JavaScript ile tarayıcı üzerinde böyle deneyler tasarlamak; DOM, event yönetimi, veri modelleme ve kullanıcı deneyimi bilgisini aynı projede buluşturur. Küçük başlayın: üç soru, bir sayaç ve basit bir skor ekranı yeterli. Sonra rastgeleleştirme, grafikler, localStorage ve erişilebilirlik ekleyerek projenizi gerçek bir interaktif araştırma aracına dönüştürebilirsiniz.

Dinamik sayfa oluşturmanın temel fikri basittir: kullanıcıdan gelen istek, sunucuda işlenir ve her kullanıcıya bağlama göre farklı bir çıktı döner. Bunu küçük bir formülle düşünebiliriz: $Sayfa = Veri + Yetki + Şablon$. Örneğin aynı konu sayfası, moderatöre silme butonu gösterirken normal üyeye sadece yanıtla butonu gösterebilir.

Bir forumun veritabanı modeli genellikle birkaç ana tablo etrafında döner: kullanıcılar, konular, mesajlar, kategoriler ve roller. Basit ilişki şöyle kurulabilir: bir kullanıcının birçok mesajı vardır, bir konunun birçok mesajı vardır. Matematiksel olarak bunu $User \rightarrow Posts$ ve $Topic \rightarrow Posts$ ilişkileriyle düşünebiliriz. Trafik arttığında sorgu sayısı da önem kazanır; toplam maliyet kabaca $T_{toplam}=T_{sql}+T_{php}+T_{network}$ şeklinde okunabilir.

Güvenli iletişimin kalbi ise hazırlıklı sorgulardır. Kullanıcıdan gelen metni doğrudan SQL cümlesine eklemek, SQL injection davetiyesidir. PDO ile parametre bağlamak, veriyi komut olmaktan çıkarıp yalnızca veri haline getirir.

<?php
$pdo = new PDO(
    'mysql:host=localhost;dbname=forum;charset=utf8mb4',
    'forum_user',
    'secret_password',
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);

$title = trim($_POST['title'] ?? '');
$userId = $_SESSION['user_id'] ?? null;

if ($title === '' || !$userId) {
    http_response_code(400);
    exit('Geçersiz istek');
}

$stmt = $pdo->prepare(
    'INSERT INTO topics (user_id, title, created_at) VALUES (:user_id, :title, NOW())'
);
$stmt->execute([
    'user_id' => $userId,
    'title' => $title
]);

Bu kodun görevi yeni bir konu başlığı eklemektir. Dikkat ederseniz $title doğrudan SQL içine gömülmez; :title parametresine bağlanır. Böylece kullanıcı başlığa garip karakterler yazsa bile sorgunun yapısı bozulmaz.

Dinamik sayfa üretirken güvenlik sadece veritabanı ile bitmez. Mesaj içeriğini ekrana basarken HTML kaçışlama gerekir. Aksi halde biri konuya zararlı JavaScript yazabilir. Basit çıktı örneği:

<p><?= htmlspecialchars($post['body'], ENT_QUOTES, 'UTF-8') ?></p>

Ayrıca forumlar sosyal sistemlerdir; teknik tasarım topluluk davranışını etkiler. Bildirimler, rozetler, beğeniler ve moderasyon kuyrukları sadece özellik değil, katılım mekanizmasıdır. Ancak her yeni özellik yeni veri ilişkileri ve yeni güvenlik kontrolleri demektir.

Modern PHP ekosisteminde Laravel veya Symfony gibi çatılar, yönlendirme, ORM, middleware ve CSRF koruması sunarak bu yükü azaltır. Yine de temeli anlamak önemlidir: istek gelir, kimlik doğrulanır, yetki kontrol edilir, güvenli sorgu çalışır, veri temizlenir ve şablona aktarılır. Kısacası iyi bir topluluk platformu, yalnızca konuşma alanı değil; veritabanı, güvenlik ve kullanıcı deneyiminin dengeli bir orkestrasıdır.

Bu işin teorik temeli üç katmandan oluşur: ilişkisel model, dilsel ön işleme ve semantik yakınlık. İlişkisel modelde her metin; yazar, eser, bölüm, cümle ve token gibi parçalara ayrılır. Dilsel ön işlemede kelimeler küçük harfe çevrilir, noktalama temizlenir, kök veya lemma bulunur. Semantik yakınlıkta ise kelimelerin aynı bağlamlarda görünme sıklığı ölçülür. Basit fikir şudur: İki kavram benzer cümlelerde sık görünüyorsa anlam uzayında birbirine yakındır. ``

Matematiksel olarak birlikte görünme oranını şöyle düşünebiliriz: $P(a,b)=\frac{count(a,b)}{N}$, burada $count(a,b)$ iki kelimenin aynı pencere içinde kaç kez geçtiğini, $N$ ise toplam pencere sayısını gösterir. Daha kullanışlı bir ölçü olan PMI ise $PMI(a,b)=\log\frac{P(a,b)}{P(a)P(b)}$ formülüyle beklenenden güçlü ilişkileri yakalar. Örneğin töz ve nitelik sıradan sıklıkta görünse bile birlikte görünmeleri beklenenden fazlaysa felsefi açıdan anlamlı bir bağ oluşur.

Örnek bir şema şöyle tasarlanabilir: authors, works, sentences, tokens, roots ve co_occurrences. Token tablosu her kelimeyi satır olarak tutar; root tablosu ise etimolojik veya morfolojik kökeni saklar. Böylece hem metinsel hem de tarihsel sorgular yazabiliriz.

-- Aynı kökten gelen kelimelerin filozoflara göre dağılımı
SELECT
  a.name AS philosopher,
  r.root_text AS root,
  COUNT(*) AS usage_count
FROM tokens t
JOIN sentences s ON s.id = t.sentence_id
JOIN works w ON w.id = s.work_id
JOIN authors a ON a.id = w.author_id
JOIN roots r ON r.id = t.root_id
WHERE r.root_text IN ('logos', 'ratio', 'nous')
GROUP BY a.name, r.root_text
ORDER BY usage_count DESC;

Bu sorgu, farklı dillerde akıl, söz, düzen veya ilke anlamlarına yaklaşan kökleri filozof bazında karşılaştırır. Elbette burada felsefi yorum SQL’den çıkmaz; SQL yalnızca izleri görünür kılar. Yorum, araştırmacının tarihsel ve kavramsal bilgisinde başlar.

Daha heyecanlı kısım semantik ağdır. Cümle içinde beş kelimelik bir pencere düşünelim. Eğer özgürlük ile zorunluluk aynı pencerede sık görülüyorsa aralarında kenar oluşur. Aşağıdaki sorgu bu ilişkiyi kabaca çıkarır:

-- Aynı cümlede geçen kavram çiftlerini bulma
SELECT
  t1.lemma AS concept_a,
  t2.lemma AS concept_b,
  COUNT(*) AS co_count
FROM tokens t1
JOIN tokens t2
  ON t1.sentence_id = t2.sentence_id
 AND t1.position < t2.position
 AND ABS(t1.position - t2.position) <= 5
WHERE t1.pos IN ('NOUN', 'ADJ')
  AND t2.pos IN ('NOUN', 'ADJ')
  AND t1.lemma <> t2.lemma
GROUP BY t1.lemma, t2.lemma
HAVING COUNT(*) >= 10
ORDER BY co_count DESC;

Burada position kelimenin cümledeki sırasıdır. ABS ile pencere sınırı belirlenir. Böylece bütün metni torbaya atmak yerine yakın bağlamı dikkate alırız. Bu, Aristoteles’te form-madde çiftini, Spinoza’da töz-kip ilişkisini, Kant’ta deneyim-akıl gerilimini daha görünür hâle getirebilir.

Performans için indeksler şarttır. Devasa metinlerde sentence_id, lemma, root_id ve position alanlarına indeks eklemek sorgu süresini dramatik biçimde azaltır. Ayrıca sık kullanılan sonuçlar materialized view olarak saklanabilir.

CREATE INDEX idx_tokens_sentence_position
ON tokens(sentence_id, position);

CREATE MATERIALIZED VIEW concept_edges AS
SELECT t1.lemma AS source, t2.lemma AS target, COUNT(*) AS weight
FROM tokens t1
JOIN tokens t2 ON t1.sentence_id = t2.sentence_id
WHERE t1.position < t2.position
GROUP BY t1.lemma, t2.lemma;

Sonuçta SQL, felsefeyi otomatikleştiren sihirli bir değnek değildir; daha çok karanlık bir arşivde güçlü bir el feneridir. Hangi kavramların hangi köklerden beslendiğini, hangi eserlerde yoğunlaştığını ve hangi semantik komşularla gezdiğini gösterir. Filozoflar argüman kurar, SQL ise bu argümanların metin içindeki ayak izlerini sabırla sayar.

Alan Turing’in 1950’de önerdiği ünlü “taklit oyunu”, bir makinenin düşünüp düşünmediğini doğrudan sormak yerine daha pratik bir soru sorar: Bir insan değerlendirici, yazılı sohbet üzerinden makineyi insandan ayırt edemezse, makine zeki davranış sergiliyor sayılabilir mi? Bu yaklaşım zekâyı içsel bir özden çok gözlemlenebilir davranış üzerinden ele alır. Yani test, beynin içinde ne olduğunu değil, konuşmanın karşı tarafta nasıl bir izlenim bıraktığını ölçer.

Burada psikoloji devreye girer. İnsan iletişimi yalnızca bilgi aktarımı değildir; niyet, bağlam, bellek, duygu tonu ve beklenti yönetimi içerir. Bir kullanıcı “Bugün berbat geçti” dediğinde iyi bir sistem sadece “Üzgünüm” dememeli; cümlenin duygusal ağırlığını, devam sorusu ihtiyacını ve fazla mekanik görünmeme riskini de hesaba katmalıdır. Bu yüzden modern yapay zekâ sistemlerinde dil modeli kadar “sohbet dinamiği modeli” de önemlidir.

Böyle sistemler geliştirmek için önce konuşmayı parçalara ayırmak gerekir. Niyet tanıma, duygu analizi, bağlam takibi ve cevap üretimi ayrı katmanlar gibi düşünülebilir. Aşağıdaki küçük Python örneği, oyuncak seviyesinde bir sohbet değerlendiricisi kurar. Amaç, cevabın yalnızca anahtar kelimeye değil, duygu tonuna da tepki vermesidir.

class MiniTuringBot:
    def __init__(self):
        self.memory = []

    def detect_emotion(self, text):
        sad_words = ['kötü', 'berbat', 'üzgün', 'yoruldum']
        happy_words = ['harika', 'güzel', 'sevindim', 'başardım']
        if any(word in text.lower() for word in sad_words):
            return 'sad'
        if any(word in text.lower() for word in happy_words):
            return 'happy'
        return 'neutral'

    def reply(self, user_text):
        emotion = self.detect_emotion(user_text)
        self.memory.append(user_text)

        if emotion == 'sad':
            return 'Bunu yaşaman zor olmalı. İstersen ne olduğunu birlikte açabiliriz.'
        if emotion == 'happy':
            return 'Bu güzel haber! Sence bunu mümkün kılan en önemli şey neydi?'
        return 'Anladım. Biraz daha detay verirsen daha iyi takip edebilirim.'

bot = MiniTuringBot()
print(bot.reply('Bugün gerçekten berbat geçti'))

Bu kod “zeki” değildir; fakat önemli bir fikri gösterir: İnsan benzeri sohbet, tek seferlik cevaplardan değil, durum değerlendirmesinden oluşur. Gerçek sistemlerde bu yapı büyük dil modelleri, vektör veritabanları, kullanıcı profilleri ve güvenlik filtreleriyle genişletilir. Yine de temel soru değişmez: Cevap, karşıdaki kişinin zihinsel durumuna uygun mu?

Turing Testi’nin en eğlenceli tarafı, bizi “zeka nedir?” sorusundan “zeki görünmek ne demektir?” sorusuna taşır. Bu ikisi aynı şey değildir. Bir sistem insanı kandırabilir ama gerçekten anlamıyor olabilir; yine de pratik yazılım geliştirmede kullanıcı deneyimi açısından bu inandırıcılık değerlidir. Özellikle eğitim, müşteri desteği, terapi destek araçları ve oyun karakterlerinde dilin psikolojik dokusu kritik hale gelir.

Sonuç olarak Turing Testi, yapay zekâ geliştiricilerine hâlâ güçlü bir pusula sunar. Daha iyi modeller kurmak istiyorsanız sadece algoritmaya değil, insanın konuşurken yaptığı küçük bilişsel numaralara da bakın: ima, tereddüt, bağlam, duygu ve hatırlama. Çünkü bazen bir botu inandırıcı yapan şey en doğru cevabı vermesi değil, doğru anda “hmm, bunu biraz açalım” diyebilmesidir.

Temel fikir, arama ağacını küçültmektir. Bunun için üç ana silahımız var: daha iyi veri yapısı, daha iyi sezgisel fonksiyon ve tekrarları engelleyen bellek yönetimi.

Labirent için A* genellikle yıldız oyuncudur. Çünkü hedefe olan Manhattan mesafesi gibi basit bir sezgisel, algoritmanın boş koridorlarda kaybolmasını engeller. A* şu puanı kullanır: $f(n)=g(n)+h(n)$. Burada $g(n)$ başlangıçtan gelinen maliyet, $h(n)$ ise hedefe tahmini uzaklıktır. Eğer $h(n)$ asla gerçek maliyeti aşmıyorsa, yani kabul edilebilir ise, A* en kısa yolu bulur.

from heapq import heappush, heappop

def astar(start, goal, neighbors, heuristic):
    pq = []
    heappush(pq, (0, start))
    cost = {start: 0}
    parent = {start: None}

    while pq:
        _, node = heappop(pq)
        if node == goal:
            return parent

        for nxt, step_cost in neighbors(node):
            new_cost = cost[node] + step_cost
            if nxt not in cost or new_cost < cost[nxt]:
                cost[nxt] = new_cost
                priority = new_cost + heuristic(nxt, goal)
                heappush(pq, (priority, nxt))
                parent[nxt] = node
    return None

Rubik Küp tarafında mesele daha serttir. Her durumda 18 temel hamle düşünürsek dallanma faktörü yüksektir. Burada IDA* öne çıkar: A* mantığını derinlik sınırıyla birleştirir, ancak devasa öncelik kuyruğu tutmaz. Özellikle desen veritabanları, yani pattern database, sezgisel değeri önceden hesaplayarak büyük hız kazandırır. Bunun bedeli bellektir; klasik takas: zaman mı, RAM mi?

Optimizasyonda dil seçimi kadar temsil biçimi de önemlidir. Labirenti karakter matrisi yerine bitset ile saklamak belleği azaltır. Rubik Küp için yüz renklerini uzun dizilerde tutmak yerine permütasyon ve yönelim dizileri kullanmak hem hızlı karşılaştırma hem de daha küçük hash üretir. Ziyaret edilen durumları set içinde tutmak tekrarları keser; fakat uzay karmaşıklığını artırır. Bu yüzden IDA* gibi yöntemler bazen bilinçli olarak daha az hatırlar, daha çok tekrar hesaplar.

Pratik reçete şöyle: Önce doğru algoritmayı seç, sonra sezgisel fonksiyonu iyileştir, ardından profil çıkar. Çünkü tahminle optimizasyon yapmak, gözleri kapalı labirent çözmeye benzer. Labirentte A, Rubik Küpünde IDA ve desen veritabanları çoğu zaman iyi başlangıçtır. Big O bize haritanın ölçeğini verir; gerçek performansı ise veri yapıları, önbellek davranışı ve dilin çalışma modeli belirler. Kısacası hızlı çözücü yazmak, sadece kodlamak değil, arama uzayını ikna sanatıdır.

Mirasın temelinde is-a ilişkisi vardır. Yani “Büyücü bir Karakterdir” diyebiliyorsak, Wizard sınıfı Character sınıfından türeyebilir. Matematiksel olarak bunu kümeler gibi düşünebiliriz: Wizard \subset Character değil, daha doğru ifadeyle Wizard nesneleri Character arayüzünü de taşır. Bir taban sınıfın özellik kümesi $B$, türetilmiş sınıfın eklediği özellikler $E$ ise, türetilmiş sınıfın toplam yeteneği yaklaşık olarak $D = B \cup E$ şeklinde düşünülebilir.

Temel Miras Söz Dizimi

C++’ta miras şu şekilde tanımlanır:

class Character {
public:
    string name;
    int health;

    void move() {
        cout << name << " hareket ediyor." << endl;
    }
};

class Wizard : public Character {
public:
    void castSpell() {
        cout << name << " büyü yapıyor!" << endl;
    }
};

Burada Wizard, Character sınıfından public miras alır. Bu sayede Wizard nesnesi hem name, health, move() üyelerine hem de kendi castSpell() fonksiyonuna sahip olur.

int main() {
    Wizard merlin;
    merlin.name = "Merlin";
    merlin.health = 100;
    merlin.move();
    merlin.castSpell();
}

Bu kodda move() fonksiyonu Wizard içinde yazılmadığı halde çalışır; çünkü taban sınıftan devralınmıştır. Bu, mirasın en pratik tarafıdır: ortak davranışları merkezileştirmek.

Public, Protected ve Private Miras

C++’ta miras türü, taban sınıftaki erişim seviyelerinin türetilmiş sınıfa nasıl aktarılacağını belirler.

Günlük kullanımda en sık public miras tercih edilir. Çünkü nesne yönelimli tasarımda türetilmiş sınıfın taban sınıf yerine geçebilmesi beklenir. Buna Liskov Yerine Geçme Prensibi denir: Eğer Wizard bir Character ise, Character* bekleyen bir fonksiyona Wizard* gönderebilmeliyiz.

Protected: Aile Sırrı

private üyeler sadece sınıfın kendisi tarafından erişilebilir. Ancak bazen türetilmiş sınıfların da bazı verilere erişmesi gerekir. Bu durumda protected kullanılır.

class Character {
protected:
    int health;

public:
    Character(int h) : health(h) {}

    void showHealth() {
        cout << "Can: " << health << endl;
    }
};

class Warrior : public Character {
public:
    Warrior() : Character(150) {}

    void takeDamage(int amount) {
        health -= amount;
    }
};

Burada health, dış dünyaya kapalıdır ama Warrior tarafından erişilebilir. Bu, kapsüllemeyi tamamen bozmadan esneklik sağlar.

Fonksiyon Ezme ve Sanal Fonksiyonlar

Mirasın asıl yıldızı polimorfizm ile parlar. Taban sınıftaki bir davranışı türetilmiş sınıfta farklılaştırmak için virtual kullanılır.

class Character {
public:
    virtual void attack() {
        cout << "Karakter saldırıyor." << endl;
    }
};

class Archer : public Character {
public:
    void attack() override {
        cout << "Okçu ok fırlatıyor!" << endl;
    }
};

virtual, çalışma zamanında doğru fonksiyonun seçilmesini sağlar. Bu mekanizma dinamik bağlama olarak bilinir. Basitçe maliyetini şöyle düşünebiliriz: normal fonksiyon çağrısı $O(1)$ iken sanal çağrı da pratikte $O(1)$ kabul edilir, fakat küçük bir yönlendirme maliyeti vardır.

Yapıcı ve Yıkıcı Fonksiyonlara Dikkat

Türetilmiş sınıf oluşturulurken önce taban sınıfın yapıcısı, sonra türetilmiş sınıfın yapıcısı çalışır. Yıkımda ise sıra tersinedir. Eğer taban sınıf üzerinden türetilmiş nesneleri sileceksen, yıkıcı fonksiyon virtual olmalıdır.

class Character {
public:
    virtual ~Character() {
        cout << "Character yok edildi." << endl;
    }
};

Aksi halde bellek sızıntısı veya eksik temizlik gibi tatsız sürprizlerle karşılaşabilirsin.

Ne Zaman Miras Kullanılmalı?

Miras her derde deva değildir. Eğer ilişki “bir şeydir” değil de “bir şeye sahiptir” şeklindeyse, kompozisyon daha iyi olabilir. Örneğin Car sınıfı Engine sınıfından miras almamalı; onun yerine bir Engine nesnesine sahip olmalıdır.

Sonuç olarak C++ sınıf mirası, doğru kullanıldığında kod tekrarını azaltır, tasarımı anlaşılır kılar ve polimorfizmle güçlü mimariler kurmanı sağlar. Ama unutma: Miras aile bağı gibidir; doğru akrabayı seçersen huzur, yanlış akrabayı seçersen sonsuz refactoring getirir!

``

Neden C++ hâlâ oyun motorlarında bu kadar güçlü?

Modern oyun motorlarında her karede binlerce nesnenin konumu güncellenir, çarpışmalar çözülür, animasyonlar karıştırılır ve GPU’ya veri gönderilir. 60 FPS hedefinde bir karenin süresi yaklaşık $16.67ms$’dir. Eğer fizik, render ve oyun mantığı bu küçük zaman penceresine sığmazsa oyuncu takılma hisseder.

C++’ın avantajı, geliştiriciye belleğin nerede, ne zaman ve nasıl kullanılacağını söyleme şansı vermesidir. İşaretçiler sayesinde veriye doğrudan erişebilir, nesneleri kopyalamadan aktarabilir ve donanım önbelleğini daha verimli kullanabiliriz.

Fizik motorunun arkasındaki basit matematik

Bir fizik motoru temelde şu soruyu her karede tekrar sorar: “Nesneler şimdi nerede olmalı?” En basit hareket güncellemesi şu formülle yapılabilir: $x_{t+dt} = x_t + v_t \cdot dt$. Burada $x$ konum, $v$ hız, $dt$ ise kareler arası zamandır.

Çarpışma tarafında iş daha eğlenceli hale gelir. Bin nesnenin birbirine çarpıp çarpmadığını saf yöntemle kontrol edersek karmaşıklık $O(n^2)$ olur. Yani 1000 nesne için yaklaşık 1 milyon karşılaştırma! Bu yüzden oyun motorları broad phase ve narrow phase gibi aşamalar kullanır.

İşaretçiler neden performans için kritik?

Oyun motorlarında en büyük düşmanlardan biri gereksiz kopyalamadır. Büyük bir RigidBody nesnesini her fonksiyona değer olarak göndermek pahalıdır. Bunun yerine işaretçi veya referans kullanılır. Böylece nesne bellekte tek yerde durur, sistemler aynı veriye erişir.

struct Vec3 {
    float x, y, z;
};

struct RigidBody {
    Vec3 position;
    Vec3 velocity;
    float mass;
};

void integrate(RigidBody* body, float dt) {
    if (!body) return;

    body->position.x += body->velocity.x * dt;
    body->position.y += body->velocity.y * dt;
    body->position.z += body->velocity.z * dt;
}

Bu kodda RigidBody* body, fizik nesnesinin adresini taşır. Fonksiyon nesneyi kopyalamaz; doğrudan orijinal veriyi günceller. Bu, özellikle binlerce gövdeyi her kare güncelleyen fizik sistemlerinde ciddi fark yaratır.

Bellek havuzları: Motorun gizli turbo modu

Bir sahnede sürekli mermi, parçacık, düşman veya geçici temas noktası oluşturup yok etmek klasik new/delete ile maliyetli olabilir. Çünkü işletim sisteminden sık sık bellek istemek yavaştır ve bellek parçalanmasına yol açar. Çözüm: önceden büyük bir blok ayırmak ve nesneleri bu bloktan dağıtmak.

class BodyPool {
    RigidBody bodies[1024];
    bool used[1024] = {};

public:
    RigidBody* create() {
        for (int i = 0; i < 1024; ++i) {
            if (!used[i]) {
                used[i] = true;
                return &bodies[i];
            }
        }
        return nullptr;
    }

    void destroy(RigidBody* body) {
        int index = static_cast<int>(body - bodies);
        if (index >= 0 && index < 1024) used[index] = false;
    }
};

Bu yapı, nesneleri bitişik bellekte tuttuğu için CPU önbelleğine dosttur. Yani işlemci “bir sonraki veriyi” tahmin edip daha hızlı erişebilir. Karmaşık sahnelerde bu fark, teoriden çıkıp FPS grafiğinde görünür hale gelir.

Sonuç: Güç büyük, sorumluluk da büyük

C++ ile oyun motoru geliştirmek, spor araba kullanmaya benzer: inanılmaz hızlanır ama virajı yanlış alırsanız bariyerle tanışırsınız. İşaretçiler, bellek havuzları, RAII ve veri odaklı tasarım birlikte kullanıldığında fizik motorları daha hızlı, üç boyutlu dünyalar daha akıcı hale gelir. Kısacası C++ hâlâ oyun motorlarının kalbinde atıyorsa sebebi nostalji değil; belleğe yakın durmanın verdiği ham güçtür.

Asal Sayı Nedir?

Asal sayı, sadece 1’e ve kendisine tam bölünebilen 1’den büyük doğal sayıdır.

Örnek asal sayılar:

2, 3, 5, 7, 11, 13, 17, 19, 23

Asal olmayan sayılara asal olmayan sayı veya bileşik sayı denir.

Örneğin:

• 4 asal değildir çünkü 1, 2 ve 4’e bölünür.
• 9 asal değildir çünkü 1, 3 ve 9’a bölünür.
• 10 asal değildir çünkü 1, 2, 5 ve 10’a bölünür.

Önemli bilgi: 1 asal sayı değildir.

1. Bir Sayının Asal Olup Olmadığını Bulma

İlk olarak kullanıcıdan bir sayı alalım ve bu sayının asal olup olmadığını kontrol edelim.

sayi = int(input("Bir sayı giriniz: "))

asal_mi = True

if sayi <= 1:
    asal_mi = False
else:
    for i in range(2, sayi):
        if sayi % i == 0:
            asal_mi = False
            break

if asal_mi:
    print(sayi, "asal sayıdır.")
else:
    print(sayi, "asal sayı değildir.")

Program Nasıl Çalışır?

Bu programda şu adımlar gerçekleşir:

1. Kullanıcıdan bir sayı alınır.
2. Başlangıçta sayının asal olduğu varsayılır.
3. Eğer sayı 1 veya daha küçükse asal değildir.
4. Sayı, 2’den başlayarak kendisinden bir önceki sayıya kadar bölünmeye çalışılır.
5. Eğer tam bölünürse asal değildir.
6. Hiçbir sayıya tam bölünmezse asaldır.

Örnek Çalışma

Bir sayı giriniz: 7
7 asal sayıdır.

Bir sayı giriniz: 12
12 asal sayı değildir.

2. Daha Kolay Anlamak İçin Bölme Kontrolü

Python’da % işareti mod alma anlamına gelir. Yani bölme işleminden kalan sayıyı verir.

Örnek:

print(10 % 2)  # 0
print(10 % 3)  # 1
print(15 % 5)  # 0

Eğer bir sayının başka bir sayıya bölümünden kalan 0 ise, bu sayı tam bölünür.

Örneğin:

12 % 3 == 0

Bu ifade doğrudur çünkü 12, 3’e tam bölünür.

3. Fonksiyon Kullanarak Asal Sayı Kontrolü

Şimdi aynı işlemi bir fonksiyon ile yapalım.

Fonksiyonlar, aynı kodu tekrar tekrar yazmamızı engeller.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

numara = int(input("Bir sayı giriniz: "))

if asal_mi(numara):
    print(numara, "asal sayıdır.")
else:
    print(numara, "asal sayı değildir.")

Fonksiyon Ne İşe Yarar?

Bu bölümde asal_mi adında bir fonksiyon yazdık.

def asal_mi(sayi):

Bu fonksiyon içine bir sayı gönderiyoruz. Fonksiyon bize True veya False döndürüyor.

4. 1’den N’e Kadar Olan Asal Sayıları Bulma

Şimdi kullanıcıdan bir üst sınır alalım. Örneğin kullanıcı 50 girerse, 1’den 50’ye kadar olan asal sayıları ekrana yazdıralım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

ust_sinir = int(input("Üst sınırı giriniz: "))

print("Asal sayılar:")

for sayi in range(1, ust_sinir + 1):
    if asal_mi(sayi):
        print(sayi)

Örnek Çalışma

Üst sınırı giriniz: 20
Asal sayılar:
2
3
5
7
11
13
17
19

Bu program 1’den başlayıp kullanıcının girdiği sayıya kadar tüm sayıları kontrol eder.

5. Asal Sayıları Liste İçinde Saklama

Bazen asal sayıları sadece ekrana yazdırmak yerine bir listede saklamak isteyebiliriz.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

ust_sinir = int(input("Üst sınırı giriniz: "))
asal_sayilar = []

for sayi in range(1, ust_sinir + 1):
    if asal_mi(sayi):
        asal_sayilar.append(sayi)

print("Asal sayılar:", asal_sayilar)
print("Toplam asal sayı adedi:", len(asal_sayilar))

Örnek Çalışma

Üst sınırı giriniz: 30
Asal sayılar: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Toplam asal sayı adedi: 10

Burada iki yeni şey kullandık:

• append() listeye yeni eleman ekler.
• len() listenin kaç elemanlı olduğunu verir.

6. Daha Hızlı Asal Sayı Kontrolü

Bir sayının asal olup olmadığını anlamak için her zaman 2’den sayının kendisine kadar kontrol yapmamıza gerek yoktur.

Örneğin 36 sayısını düşünelim:

1 x 36
2 x 18
3 x 12
4 x 9
6 x 6
9 x 4
12 x 3
18 x 2
36 x 1

Gördüğün gibi çarpanlar bir noktadan sonra tekrar etmeye başlıyor. Bu yüzden bir sayının kareköküne kadar kontrol etmek yeterlidir.

Basitçe söylemek gerekirse:

Bir sayı asal değilse, en az bir böleni karekökünden küçük veya ona eşittir.

Python’da karekök almak için ** 0.5 kullanabiliriz.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

sayi = int(input("Bir sayı giriniz: "))

if asal_mi(sayi):
    print(sayi, "asal sayıdır.")
else:
    print(sayi, "asal sayı değildir.")

Neden Daha Hızlı?

Diyelim ki sayı 100 olsun.

İlk yöntemde 2’den 99’a kadar kontrol yapılır.

Daha hızlı yöntemde ise sadece 2’den 10’a kadar kontrol yapılır çünkü:

100'ün karekökü = 10

Bu yöntem büyük sayılarda daha hızlı çalışır.

7. Belirli Bir Aralıktaki Asal Sayıları Bulma

Şimdi kullanıcıdan başlangıç ve bitiş değerleri alalım. Bu iki sayı arasındaki asal sayıları bulalım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

baslangic = int(input("Başlangıç sayısını giriniz: "))
bitis = int(input("Bitiş sayısını giriniz: "))

print(baslangic, "ile", bitis, "arasındaki asal sayılar:")

for sayi in range(baslangic, bitis + 1):
    if asal_mi(sayi):
        print(sayi)

Örnek Çalışma

Başlangıç sayısını giriniz: 10
Bitiş sayısını giriniz: 50
10 ile 50 arasındaki asal sayılar:
11
13
17
19
23
29
31
37
41
43
47

8. İlk N Tane Asal Sayıyı Bulma

Bu kez kullanıcı kaç tane asal sayı görmek istediğini girsin.

Örneğin kullanıcı 10 girerse, ilk 10 asal sayıyı yazdıralım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

adet = int(input("Kaç tane asal sayı yazdırılsın? "))
bulunan = 0
sayi = 2

while bulunan < adet:
    if asal_mi(sayi):
        print(sayi)
        bulunan += 1

    sayi += 1

Bu Programda Ne Öğrendik?

Bu programda while döngüsü kullandık.

while döngüsü, bir koşul doğru olduğu sürece çalışır.

while bulunan < adet:

Bu satırın anlamı şudur:

Bulunan asal sayı miktarı, istenen adetten küçük olduğu sürece devam et.

9. Mini Proje: Asal Sayı Menüsü

Şimdi öğrendiklerimizi küçük bir programa dönüştürelim. Kullanıcı menüden seçim yapsın.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

while True:
    print("\n--- Asal Sayı Programı ---")
    print("1 - Bir sayının asal olup olmadığını kontrol et")
    print("2 - 1'den N'e kadar asal sayıları yazdır")
    print("3 - Belirli aralıktaki asal sayıları yazdır")
    print("4 - Çıkış")

    secim = input("Seçiminiz: ")

    if secim == "1":
        sayi = int(input("Sayı giriniz: "))
        if asal_mi(sayi):
            print(sayi, "asal sayıdır.")
        else:
            print(sayi, "asal sayı değildir.")

    elif secim == "2":
        ust_sinir = int(input("Üst sınır giriniz: "))
        for sayi in range(1, ust_sinir + 1):
            if asal_mi(sayi):
                print(sayi)

    elif secim == "3":
        baslangic = int(input("Başlangıç sayısı: "))
        bitis = int(input("Bitiş sayısı: "))
        for sayi in range(baslangic, bitis + 1):
            if asal_mi(sayi):
                print(sayi)

    elif secim == "4":
        print("Programdan çıkılıyor...")
        break

    else:
        print("Hatalı seçim yaptınız.")

Bu mini proje ile şunları kullanmış olduk:

• if-elif-else
• for döngüsü
• while döngüsü
• fonksiyonlar
• listeler ve sayılarla işlem yapma

Sık Yapılan Hatalar

1. 1 Sayısını Asal Kabul Etmek

Yanlış:

if sayi == 1:
    print("Asal")

Doğru:

if sayi <= 1:
    print("Asal değil")

2. break Kullanmayı Unutmak

Bir sayı asal değilse, bölen bulunduğu anda döngüyü durdurabiliriz.

if sayi % i == 0:
    asal_mi = False
    break

Bu programı daha hızlı yapar.

3. Girilen Değeri Sayıya Çevirmemek

input() her zaman metin yani string döndürür. Matematik işlemleri için int() kullanmalıyız.

sayi = int(input("Sayı giriniz: "))

Alıştırmalar

Aşağıdaki alıştırmaları yaparak konuyu daha iyi öğrenebilirsin:

1. Kullanıcıdan 5 sayı alıp hangilerinin asal olduğunu yazdıran program yaz.
2. 1 ile 100 arasındaki asal sayıları bir listeye ekle ve listeyi yazdır.
3. Kullanıcının girdiği iki sayı arasındaki asal sayıların toplamını bulan program yaz.
4. İlk 20 asal sayıyı ekrana yazdır.
5. Asal sayıları yan yana yazdıran bir program yaz.

Örnek yan yana yazdırma:

print(sayi, end=" ")

Sonuç

Bu yazıda Python ile asal sayıları bulmayı öğrendik. Önce bir sayının asal olup olmadığını kontrol ettik, sonra belirli aralıklardaki asal sayıları bulduk ve en sonunda menülü küçük bir program yaptık.

Asal sayı programları, algoritma mantığını geliştirmek için çok güzel örneklerdir. Çünkü bu programlarda döngüler, koşullar, fonksiyonlar ve listeler birlikte kullanılır.