Önce modülü etkinleştirelim:

sudo modprobe snd-aloop
aplay -l
arecord -l

Kalıcı yapmak için /etc/modules-load.d/alsa-loopback.conf içine şu satır eklenebilir:

snd-aloop

Ses zincirimiz teorik olarak şöyle çalışır:

Gerçek zamanlı ses işlemede en önemli denklem gecikmedir. Örnekleme frekansı $f_s$ ve tampon boyutu $N$ ise tek tampon gecikmesi yaklaşık şöyledir:

$L = \frac{N}{f_s}$

Örneğin $N=256$ ve $f_s=48000$ için $L \approx 5.3ms$ olur. Bu değer küçükse pedal hızlı tepki verir; ancak çok küçültürsek CPU yetişemez ve çıtırtılar başlar. Yani düşük gecikme ile kararlılık arasında tatlı bir denge ararız.

Yankı efekti temelde gecikmiş sinyalin tekrar karıştırılmasıdır:

$y[n] = x[n] + g \cdot x[n-D]$

Burada $D$ gecikme örneği, $g$ ise geri besleme veya karışım miktarıdır. Pitch değiştirme ise daha hilelidir; sesi hızlandırıp/yavaşlatmak perdeyi değiştirir ama süreyi de bozar. Basit bir pedal prototipinde kısa tamponlar üzerinde yeniden örnekleme kullanabiliriz. Profesyonel sonuç için phase vocoder veya granular yöntemler tercih edilir.

Aşağıdaki Python örneği, sounddevice ile girişten ses alır, basit yankı ekler ve pitch için yeniden örnekleme tabanlı kaba bir yaklaşım uygular. Üretim ortamında JACK/PipeWire daha esnek olabilir; fakat ALSA mantığını kavramak için bu örnek yeterli bir laboratuvardır.

import numpy as np
import sounddevice as sd
from scipy.signal import resample

fs = 48000
block = 512
delay_ms = 280
delay_samples = int(fs * delay_ms / 1000)
feedback = 0.35
mix = 0.55
pitch_ratio = 1.12  # 1.0 normal, >1 tiz, <1 pes

delay_buffer = np.zeros(delay_samples, dtype=np.float32)
write_pos = 0

def pitch_shift_simple(x, ratio):
    # Kısa bloğu yeniden örnekleyerek perdeyi kaba şekilde değiştirir.
    # Sonra tekrar eski blok boyuna getirir.
    if ratio == 1.0:
        return x
    n = len(x)
    stretched = resample(x, max(1, int(n / ratio)))
    shifted = resample(stretched, n)
    return shifted.astype(np.float32)

def callback(indata, outdata, frames, time, status):
    global write_pos, delay_buffer
    if status:
        print(status)

    x = indata[:, 0].astype(np.float32)
    pitched = pitch_shift_simple(x, pitch_ratio)
    y = np.zeros_like(pitched)

    for i, sample in enumerate(pitched):
        delayed = delay_buffer[write_pos]
        y[i] = sample * (1 - mix) + delayed * mix
        delay_buffer[write_pos] = sample + delayed * feedback
        write_pos = (write_pos + 1) % delay_samples

    outdata[:, 0] = y

with sd.Stream(channels=1, samplerate=fs, blocksize=block, callback=callback):
    print("Efekt pedalı çalışıyor. Durdurmak için Ctrl+C.")
    while True:
        sd.sleep(1000)

Bu kodda delay_buffer geçmiş sesi saklayan dairesel hafızadır. write_pos sona gelince başa döner; böylece sonsuz uzunlukta dizi kullanmadan yankı üretiriz. Pitch kısmı bilerek sade tutuldu: amaç algoritmanın iskeletini görmek. Daha pürüzsüz sonuç için pencereleme, overlap-add ve faz sürekliliği gerekir.

ALSA loopback yönlendirmesi için pavucontrol, PipeWire patchbay araçları veya doğrudan .asoundrc kullanılabilir. Basit testlerde mikrofonu Python uygulamasına giriş, uygulama çıkışını da Loopback oynatma cihazına vermek yeterlidir. Ardından OBS, DAW veya başka bir kayıt aracı Loopback yakalama tarafını dinleyebilir.

Sonuçta ALSA loopback bize sanal kabloyu, Python/DSP kodu ise pedalın elektronik devresini verir. Birkaç parametreyi MIDI kontrolcüye bağlayarak gerçek bir sahne pedalına yaklaşabilir; hatta zincire distortion, chorus ve compressor ekleyerek Linux tabanlı kendi mini efekt istasyonunuzu kurabilirsiniz.

``

Statik tip sisteminde bir değişkenin tipi çalışma zamanında rastgele değişmez; çoğu karar derleme aşamasında verilir. Yani program henüz çalışmadan önce derleyici şunu sorar: “Bu değişkene gerçekten bu değer atanabilir mi?” Eğer cevap hayırsa, program daha başlangıç çizgisine gelmeden uyarı alırız. Bu, özellikle büyük projelerde süper güç gibidir; çünkü hatayı kullanıcı değil, derleyici yakalar.

Basit düşünelim: int tam sayıları, double ondalıklı sayıları, string metinleri, bool ise doğru/yanlış değerlerini taşır. Matematiksel olarak bir tipin alabileceği değerleri bir küme gibi düşünebiliriz. Örneğin 32 bitlik işaretli bir tam sayı yaklaşık olarak şu aralıktadır: $-2^{31}$ ile $2^{31}-1$ arası. Bu aralığın dışındaki bir değeri int içine koymaya çalışmak, küçük bir bavula piyano sığdırmaya benzer.

Statik tipli dillerde tipleri her zaman uzun uzun yazmak zorunda değiliz. Burada otomatik tip belirleme, yani type inference devreye girer. Derleyici sağ taraftaki değere bakarak sol taraftaki değişkenin tipini çıkarır. Ancak bu, değişkenin tipsiz olduğu anlamına gelmez; sadece tipi bizim yerimize derleyici yazar.

var count = 10;        // Derleyici bunu int olarak belirler
var price = 19.99;     // double
var name = "Ada";      // string
var isActive = true;   // bool

// count = "on";       // Hata: count artık int kabul edilir

Bu örnekte var, “ne olursa olsun kabul et” demek değildir. Daha çok “tipi sağ taraftan anla ama sonra sıkı denetle” demektir. Yani type inference, statik tip sistemini zayıflatmaz; sadece daha az klavye mesaisi sağlar.

Tip dönüşümleri ise iki ana gruba ayrılır: örtük ve açık dönüşüm. Örtük dönüşüm güvenli kabul edilen, veri kaybı beklenmeyen durumlarda yapılır. Açık dönüşümde ise programcı sorumluluğu üstlenir: “Evet, bunun riskli olabileceğini biliyorum.”

int small = 42;
long big = small; // Örtük dönüşüm: int değeri long içine rahatça sığar

double ratio = 9.75;
int roundedDown = (int)ratio; // Açık dönüşüm: sonuç 9 olur

Buradaki dönüşümde $9.75 \rightarrow 9$ olur; yani bilgi kaybı yaşanır. Bu yüzden açık dönüşümler kodda küçük bir sarı ikaz levhası gibi okunmalıdır. “Burada bilinçli bir karar var” mesajı verir.

Kullanıcıdan veya dosyadan gelen veriler genellikle metindir. Bu metni sayıya çevirmek için doğrudan parse etmek yerine güvenli yöntemler tercih edilmelidir.

string input = "123";

if (int.TryParse(input, out int number))
{
    int result = number * 2;
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("Geçerli bir sayı girilmedi.");
}

TryParse, programı patlatmadan sonucu kontrol etmemizi sağlar. Kullanıcı abc yazarsa uygulama dramatik bir tiyatro sahnesi gibi çökmez; sadece uygun mesajı verir.

Bazı diller taşma kontrolleri için özel mekanizmalar sunar. Örneğin çok büyük bir sayıyı küçük tipe çevirirken değer aralığı aşılabilir. Bu durumda $x \notin [min, max]$ ise dönüşüm güvenli değildir.

checked
{
    int max = int.MaxValue;
    // int overflow = max + 1; // Taşma hatası üretir
}

Özetle değişkenler veriyi taşır, veri tipleri bu verinin kurallarını belirler, statik tip sistemi de oyunun hakemi gibi yanlış pasları erkenden düdükler. Type inference kodu sadeleştirirken güvenliği korur. Tip dönüşümlerinde ise temel soru hep aynıdır: “Bu değer hedef tipe kayıpsız ve anlamlı biçimde sığar mı?” Bu soruyu alışkanlık haline getirmek, daha sağlam ve okunabilir programlar yazmanın en pratik yollarından biridir.

Fonksiyon Nedir, Neden Bu Kadar Önemlidir?

Teorik olarak bir fonksiyon, belirli girdileri alıp belirli çıktılar üreten bir dönüşüm olarak düşünülebilir. Matematiksel gösterimle:

$f: X \rightarrow Y$

Burada $X$ giriş kümesini, $Y$ ise çıkış kümesini temsil eder. Programlamada ise bu fikir biraz daha genişler: Fonksiyonlar yalnızca değer döndürmez, bazen dosya yazabilir, ekrana çıktı verebilir veya veritabanına kayıt atabilir. Yani yan etki, yani side effect, programlama dünyasında önemli bir kavramdır.

Bir fonksiyonun temel parçaları şunlardır:

İyi tasarlanmış bir fonksiyon küçük, anlaşılır ve tek sorumluluğa sahip olmalıdır. Bu prensip, büyük projelerde kodun okunabilirliğini ciddi biçimde artırır.

Çoklu Geri Dönüş Değeri Ne Demek?

Normalde bir fonksiyonun tek bir sonuç döndürdüğünü düşünürüz. Fakat pratikte çoğu zaman birden fazla bilgiye ihtiyaç duyarız. Örneğin bir bölme işlemi yaparken hem bölümü hem kalanı almak isteyebiliriz. Matematikte bu, çıktının tek bir değer değil, bir çift olması anlamına gelir:

$f: A \rightarrow B \times C$

Buradaki $B \times C$, iki değerden oluşan bir ürün tipidir. Python gibi dillerde bu çoğunlukla tuple ile temsil edilir.

def bol_ve_kalan(sayi, bolen):
    bolum = sayi // bolen
    kalan = sayi % bolen
    return bolum, kalan

b, k = bol_ve_kalan(17, 5)
print('Bölüm:', b)
print('Kalan:', k)

Bu kodda fonksiyon iki değer döndürür: bolum ve kalan. Python aslında bunları perde arkasında bir tuple olarak paketler. Yani return bolum, kalan ifadesi kabaca return (bolum, kalan) gibidir.

Tek Değer mi, Çoklu Değer mi?

Çoklu dönüş her zaman daha iyi değildir. Bazen kodu sadeleştirir, bazen de anlamı bulanıklaştırır. Karar verirken aşağıdaki karşılaştırma işe yarar:

Örneğin kullanıcı doğrulama fonksiyonunda hem başarı durumunu hem de mesajı döndürmek oldukça kullanışlıdır:

def kullanici_kontrol(ad, sifre):
    if not ad:
        return False, 'Kullanıcı adı boş olamaz'
    if len(sifre) < 8:
        return False, 'Şifre en az 8 karakter olmalı'
    return True, 'Giriş bilgileri geçerli'

basarili, mesaj = kullanici_kontrol('ada', '1234567')
print(mesaj)

Burada ilk değer mantıksal sonucu, ikinci değer ise açıklamayı temsil eder. Bu desen özellikle hata yönetiminde çok sevilir.

Daha Okunabilir Alternatif: Sözlük Döndürmek

Eğer dönen değer sayısı artıyorsa tuple yerine sözlük döndürmek daha açıklayıcı olabilir:

def analiz_et(metin):
    kelimeler = metin.split()
    return {
        'karakter_sayisi': len(metin),
        'kelime_sayisi': len(kelimeler),
        'ilk_kelime': kelimeler[0] if kelimeler else None
    }

sonuc = analiz_et('Fonksiyonlar kodu düzenler')
print(sonuc['kelime_sayisi'])

Bu yöntem, özellikle ekip çalışmalarında yanlış sırayla değişken atama riskini azaltır. a, b, c gibi belirsiz isimler yerine kelime_sayisi gibi açık alanlar kullanılır.

Sonuç

Fonksiyonlar, modüler kod yazmanın temel taşıdır. Kod tekrarını azaltır, test etmeyi kolaylaştırır ve karmaşık problemleri küçük parçalara böler. Çoklu geri dönüş değerleri ise fonksiyonları daha ifade gücü yüksek hale getirir. Ancak önemli kural şudur: Dönen değerler gerçekten birlikte anlamlıysa çoklu dönüş kullan; sayı arttığında ise sözlük, sınıf veya özel veri yapılarıyla kodu daha okunabilir hale getir. Kısacası fonksiyonlar kodun lego parçalarıysa, çoklu dönüş değerleri de aynı kutudan çıkan bonus parçalar gibidir: Doğru yerde kullanıldığında yapıyı hem sağlamlaştırır hem de eğlenceli hale getirir.

Kuruluma başlamadan önce birkaç temel kavramı netleştirelim:

İlk adım Go’yu kurmak. Resmî site olan https://go.dev/dl/ adresine gidin ve işletim sisteminize uygun paketi indirin. Windows kullanıyorsanız .msi kurulum dosyası genellikle yeterlidir. macOS tarafında .pkg dosyası veya Homebrew ile brew install go kullanılabilir. Linux’ta paket yöneticinizden kurabilir ya da resmî arşivi /usr/local altına açabilirsiniz.

Kurulumdan sonra terminali açıp şu komutu çalıştırın:

go version

Bu komut size kurulu Go sürümünü göstermelidir. Örneğin go version go1.22 linux/amd64 gibi bir çıktı görüyorsanız tebrikler, derleyici sahneye çıktı! Eğer komut bulunamıyorsa sorun büyük ihtimalle PATH ayarındadır. PATH, işletim sisteminin komutları nerede arayacağını belirleyen listedir. Matematiksel düşünürsek çalıştırılabilir dosya arama işlemi bir küme üzerinde yapılır: $PATH = {d_1, d_2, d_3, …}$. Go’nun bin klasörü bu kümeye eklenmelidir.

Şimdi VS Code tarafına geçelim. VS Code’u açın, Extensions bölümüne girin ve Microsoft tarafından sağlanan Go eklentisini kurun. Bu eklenti tek başına güzeldir ama asıl sihir gopls ile gelir. Bir .go dosyası açtığınızda VS Code genellikle eksik araçları kurmak isteyecektir. Onay verin; otomatik tamamlama, hata işaretleme, biçimlendirme ve tanıma özellikleri aktif olacaktır.

Aşağıdaki tablo, sade bir Go geliştirme ortamında hangi parçanın ne kattığını özetler:

Artık küçük bir proje oluşturalım. Terminalde şu adımları uygulayın:

mkdir merhaba-go
cd merhaba-go
go mod init example.com/merhaba-go

Buradaki go mod init, projeniz için bir go.mod dosyası üretir. Bu dosya, projenin kimliği ve bağımlılıkları için merkezdir. Modern Go geliştirmede proje formülü kabaca şöyledir: proje = kaynak kod + go.mod + bağımlılıklar.

Şimdi main.go dosyasını oluşturun:

package main

import "fmt"

func main() {
    mesaj := "Merhaba Go, ben geldim!"
    fmt.Println(mesaj)
}

Bu kodda package main, çalıştırılabilir bir program yazdığımızı söyler. import "fmt", ekrana yazı basmak için standart kütüphaneden fmt paketini getirir. main fonksiyonu ise programın başlangıç noktasıdır. mesaj := ifadesi Go’nun kısa değişken tanımlama biçimidir; derleyici türü kendisi çıkarır.

Programı çalıştırmak için:

go run .

Derlemek isterseniz:

go build

go run hızlı denemeler için idealdir; go build ise çalıştırılabilir çıktı üretir. Yani go run mutfakta tadım yapmak, go build ise yemeği tabağa koymaktır.

Son olarak VS Code ayarlarında Format On Save seçeneğini açmanızı öneririm. Go kültüründe biçimlendirme tartışması minimumdur; gofmt ne derse o olur. Bu da ekip içinde “süslü parantez sağda mı solda mı?” savaşlarını bitirir.

Özetle: Go SDK’yı kurduk, PATH kontrolünü yaptık, VS Code’a Go eklentisini ve gopls desteğini ekledik, modül tabanlı bir proje başlattık ve ilk programı çalıştırdık. Artık teoriyi pratiğe dökecek temiz bir masanız var. Bundan sonrası değişkenler, fonksiyonlar, paketler ve bol bol “aa bu dil baya sadeymiş” anı!

Go’nun sözdizimi C’ye benzer ama felsefesi farklıdır. C ve C++ tarihsel olarak donanıma yakınlık, performans ve düşük seviyeli kontrol üzerine kuruludur. Go ise modern sunucu yazılımları, ağ programlama, eşzamanlılık ve bakım kolaylığı için tasarlanmıştır. Bu farkı kabaca şöyle düşünebiliriz: C/C++ programcıya motorun tüm parçalarını verir; Go ise iyi ayarlanmış bir araç sunar ve gereksiz kolları panelden kaldırır.

Teorik olarak bir dilin karmaşıklığını $K$ ile, üretkenliği $U$ ile gösterirsek basit bir sezgisel ilişki kurabiliriz: $U \approx \frac{Okunabilirlik + Araçlama}{Karmaşıklık}$. Go, bu denklemde karmaşıklık paydasını küçültmeye çalışır. Örneğin header dosyaları yoktur, sınıf hiyerarşisi yoktur, kalıtım yerine arayüzler ve bileşim tercih edilir.

Go’da değişken tanımlama oldukça yalındır. C/C++’ta tip genelde soldadır; Go’da ise isim önce gelir. Bu küçük fark, özellikle karmaşık tiplerde okunabilirliği artırır.

package main

import "fmt"

func main() {
    name := "Ada"
    age := 32
    fmt.Println(name, age)
}

Burada := kısa değişken tanımlama operatörüdür. Derleyici tipleri çıkarır; name string, age int olur. C++ tarafında auto benzer bir kolaylık sunar ama Go bu yaklaşımı dilin doğal parçası haline getirir. Yine de Go tamamen dinamik değildir; tipler derleme zamanında bellidir. Yani $tip\ güvenliği + kısa\ yazım$ hedeflenir.

Fonksiyonlarda dönüş değerleri de Go’nun karakteristik alanlarından biridir. Birden fazla değer döndürmek olağandır; hata yönetimi çoğunlukla error değeriyle yapılır.

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("sıfıra bölme")
    }
    return a / b, nil
}

C’de hata kodları, C++’ta exception mekanizması sık görülür. Go ise hatayı görünür kılar: fonksiyonu çağıran kişi hatayı açıkça kontrol eder. Bu bazen fazla satır yazdırır ama üretim sistemlerinde “hata nereden geldi?” dedektifliğini azaltır.

Go’nun C++’tan en belirgin ayrımlarından biri kalıtımı reddetmesidir. C++’ta class Dog : public Animal gibi hiyerarşiler kurulabilir. Go’da ise “bir şeyin ne olduğundan çok, ne yapabildiği” önemlidir. Interface’ler örtük uygulanır; bir struct gerekli metotlara sahipse o interface’i sağlamış olur.

type Speaker interface {
    Speak() string
}

type Robot struct{}

func (r Robot) Speak() string {
    return "bip bip"
}

Robot, açıkça Speaker olduğunu ilan etmez; Speak() metoduna sahip olduğu için Speaker gibi kullanılabilir. Bu yaklaşım ördek tiplemesine benzer ama statiktir: Eğer $Nesne \rightarrow Davranış$ eşleşmesi derleme zamanında tutarlıysa kod güvenle çalışır.

Bellek tarafında C/C++ daha keskin bıçaktır. malloc/free, new/delete, pointer aritmetiği ve yaşam süresi yönetimi güçlüdür; fakat dangling pointer, double free ve memory leak gibi canavarları da davet eder. Go pointer kullanır ama pointer aritmetiği sunmaz; ayrıca garbage collector ile çoğu yaşam süresi sorununu üstlenir. Bedeli, bazı durumlarda GC gecikmesi ve C kadar deterministik bellek kontrolü sağlayamamasıdır.

Eşzamanlılıkta Go’nun yıldızı parlar. C++ thread tabanlı düşünürken Go “goroutine” ile çok daha hafif görevler oluşturur. Channel yapısı, veriyi paylaşarak iletişim kurmak yerine iletişim kurarak veriyi paylaşma fikrini teşvik eder. Bu, CSP modeline dayanır ve kabaca $iş\ parçacığı \neq mantıksal\ görev$ ayrımını pratikleştirir.

Sonuç olarak Go, C/C++’ın mirasını tamamen reddetmez; sözdizimsel olarak onlardan esinlenir. Ancak felsefi olarak daha az özellik, daha net araçlar ve daha okunabilir ekip kodu ister. Eğer C/C++ bir laboratuvar dolusu gelişmiş cihazsa, Go düzenli bir atölyedir: Her şey elinizin altındadır, bazı çılgın deneyler yasaktır ama işinizi hızlı, temiz ve güvenli biçimde bitirme ihtimaliniz yüksektir.

Akış yönetimi neden önemlidir?

Bilgisayar programını küçük bir karar makinesi gibi düşünebiliriz. Elimizde bir durum, yani değişkenler vardır; program bu durumlara bakar ve hangi yoldan ilerleyeceğine karar verir. Matematiksel olarak bir koşul çoğu zaman şu mantıksal ifadeye benzer:

$sonuc = (yas \ge 18) \land (puan > 50)$

Burada ifade true ise bir blok, false ise başka bir blok çalışır. Go’da koşullar parantez içine alınmaz; bu, dilin sade ve okunabilir olma tercihidir.

package main

import "fmt"

func main() {
    puan := 72

    if puan >= 85 {
        fmt.Println("Harika!")
    } else if puan >= 50 {
        fmt.Println("Geçtin, ama kahveye devam.")
    } else {
        fmt.Println("Tekrar deneme zamanı.")
    }
}

Bu örnekte program, puan değerine göre yalnızca bir yolu seçer. if ilk doğru koşulu yakaladığında devamındaki else if bloklarına bakmaz. Yani akış, gereksiz kontrol yapmadan ilerler.

if içinde kısa değişken tanımlama

Go’nun tatlı özelliklerinden biri, if satırında küçük bir hazırlık yapabilmektir. Bu özellikle hata kontrolünde çok görülür.

package main

import "fmt"

func main() {
    if sayi := 42; sayi%2 == 0 {
        fmt.Println("Çift sayı:", sayi)
    } else {
        fmt.Println("Tek sayı:", sayi)
    }
}

Burada sayi yalnızca if-else bloğunun içinde yaşar. Bu sayede değişkenin kapsamı dar tutulur. Daha az kapsam, daha az kafa karışıklığı demektir.

Go’da tek döngü: for

Go’da while veya do-while anahtar kelimeleri yoktur. İlk bakışta eksiklik gibi görünür, ama for o kadar esnektir ki hepsinin görevini üstlenir. Klasik kullanım üç parçadan oluşur:

$baslangic \rightarrow kosul \rightarrow guncelleme$

package main

import "fmt"

func main() {
    toplam := 0

    for i := 1; i <= 5; i++ {
        toplam += i
    }

    fmt.Println("Toplam:", toplam)
}

Bu kodda i değeri 1’den 5’e kadar ilerler ve toplam hesaplanır. Döngünün çalışma maliyetini kabaca $O(n)$ olarak düşünebiliriz; çünkü tekrar sayısı, veri boyutu ile doğru orantılıdır.

while gibi for kullanımı

Go’da sadece koşul yazarak while benzeri bir döngü oluşturabiliriz.

package main

import "fmt"

func main() {
    enerji := 3

    for enerji > 0 {
        fmt.Println("Kod yazılıyor... enerji:", enerji)
        enerji--
    }

    fmt.Println("Mola zamanı!")
}

Bu tarz, koşulun ne zaman bozulacağını dışarıdan kontrol etmek istediğimiz durumlarda okunaklıdır.

range ile koleksiyon gezmek

Diziler, dilimler, map’ler ve string’ler üzerinde dolaşmak için range kullanılır.

package main

import "fmt"

func main() {
    diller := []string{"Go", "Python", "Rust"}

    for indeks, dil := range diller {
        fmt.Println(indeks, dil)
    }
}

range, her turda indeks ve değeri verir. Eğer indekse ihtiyacımız yoksa _ ile görmezden gelebiliriz. Bu, Go’nun açık niyetli kod yazma felsefesine uygundur.

break ve continue: döngünün trafik levhaları

break döngüyü tamamen bitirir, continue ise mevcut turu atlayıp sonraki tura geçer.

for i := 1; i <= 10; i++ {
    if i == 7 {
        break
    }
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)
}

Bu kod 7’ye gelince durur, çift sayıları ise yazdırmadan geçer. Yani çıktı yalnızca 1, 3 ve 5 olur.

Özetle Go’da akış yönetimi sade ama güçlüdür. if-else programın karar mekanizmasını kurar; for ise tekrar eden işleri tek bir esnek yapı altında toplar. Bu iki aracı iyi kavramak, Go’da okunabilir ve kontrollü programlar yazmanın temelidir.

Belleği kabaca büyük bir apartman gibi düşünebiliriz. Her dairenin bir numarası, yani adresi vardır. Bir değişken de bu dairelerden birinde oturan veridir. Matematiksel olarak bellek, adreslerden değerlere giden bir fonksiyon gibi düşünülebilir: $M: A \rightarrow V$. Burada $A$ adres kümesini, $V$ ise değerleri temsil eder. Bir işaretçi ise doğrudan değeri değil, o değerin yaşadığı adresi tutar.

Go’da bir değişkenin adresini almak için &, işaretçinin gösterdiği değere erişmek için * kullanılır:

package main

import "fmt"

func main() {
    x := 42
    p := &x // x değişkeninin adresini tutar

    fmt.Println(x)
    fmt.Println(p)
    fmt.Println(*p)

    *p = 100 // p üzerinden x değerini değiştirir
    fmt.Println(x)
}

Bu örnekte p, x değişkeninin adresini saklar. *p = 100 dediğimizde “p’nin gösterdiği adresteki değeri 100 yap” deriz. Sonuçta değişen şey p değil, x olur. İşte işaretçilerin gücü burada başlar: veriyi kopyalamadan, aynı bellek konumuna erişmek.

Peki bu neden önemli? Çünkü büyük veri yapıları kopyalanmak yerine adres üzerinden taşınabilir. Diyelim ki elimizde büyük bir struct var. Bunu fonksiyona değer olarak verirsek kopya oluşur. İşaretçiyle verirsek aynı nesne üzerinde çalışırız.

type User struct {
    ID    int
    Score int
}

func increaseScore(u *User) {
    u.Score += 10
}

func main() {
    user := User{ID: 1, Score: 50}
    increaseScore(&user)
    fmt.Println(user.Score)
}

Burada increaseScore fonksiyonu *User alır. Yani bir kullanıcı kopyası değil, kullanıcının adresi fonksiyona gider. Go, u.Score yazımına izin vererek (*u).Score ifadesini bizim için sadeleştirir. Küçük ama tatlı bir ergonomi hediyesi!

Go’nun bellek modeli stack ve heap kavramlarıyla çalışır. Stack, fonksiyon çağrıları için hızlı ve düzenli bir alandır. Heap ise yaşam süresi daha belirsiz olan nesneler için kullanılır. Derleyici, escape analysis denen analizle bir değişkenin fonksiyon dışına “kaçıp kaçmadığını” inceler. Eğer kaçıyorsa heap’e taşınabilir.

Örneğin bir fonksiyon yerel değişkenin adresini döndürürse, Go bunu tehlikeli kabul edip çökmez; derleyici değişkeni heap’e taşıyabilir:

func newCounter() *int {
    count := 0
    return &count
}

C dilinde benzer bir durum büyük bir probleme dönüşebilirken Go, yaşam süresini analiz eder. Çünkü Go’da amaç, işaretçilerin performans avantajını verirken “dangling pointer” gibi klasik hataları azaltmaktır.

Garbage collector, heap üzerindeki artık erişilemeyen nesneleri temizleyen arka plan görevlisidir. Basitçe köklerden, yani global değişkenlerden, stack’teki referanslardan ve aktif goroutine’lerden başlar; erişilebilen nesneleri işaretler. Erişilemeyenler çöp kabul edilir. Bunu grafik gibi düşünebiliriz: Eğer bir nesneye giden yol yoksa, $reachable(obj) = false$ olur ve temizlik adayıdır.

Go’nun işaretçileri güvenlidir çünkü pointer arithmetic desteklenmez. Yani p + 1 diyerek keyfi adrese zıplayamayız. Bu, bellek modelini daha öngörülebilir yapar. Elbette unsafe paketiyle bu sınırlar aşılabilir; fakat adı üstünde, orası emniyet kemerini çıkarıp viraja hızlı girmek gibidir.

Sonuç olarak Go’da işaretçiler, belleği doğrudan yönetmenin kontrollü bir yoludur. Adresleri kullanırız, kopyaları azaltırız, fonksiyonlar arasında veriyi etkili biçimde paylaşırız. Arka planda derleyicinin escape analysis mekanizması ve garbage collector ikilisi, çoğu bellek temizliği yükünü bizden alır. Kısacası Go, işaretçileri bir testere gibi değil, güvenlik kilitli bir İsviçre çakısı gibi sunar: güçlü, pratik ve dikkatli kullanıldığında oldukça keyifli.

``

Temel fikir oldukça nettir: Eğer belirli koşullar sağlanıyorsa, belirli bir eylem çalıştırılır. Bu yapı programlamadaki if-else mantığının daha sistematik hâlidir. Bir kuralı basitçe $kosul -> eylem$ şeklinde düşünebiliriz. Örneğin bir mesajda hem acil kelimesi geçiyor hem de sipariş numarası bulunuyorsa, bot bunu öncelikli destek talebi olarak etiketleyebilir.

Kural tabanlı sistemlerin gücü, teorik olarak üç ana kavrama dayanır: sembolik temsil, mantıksal çıkarım ve karar akışı. Sembolik temsil, gerçek dünyadaki karmaşık ifadeleri daha işlenebilir parçalara ayırır. Mesela kullanıcının yazdığı metin; kelimeler, niyetler, anahtar ifadeler ve sayısal sinyaller olarak temsil edilir. Mantıksal çıkarım ise bu sinyallerden sonuç üretir: $skor = w1 * aciliyet + w2 * negatiflik - w3 * belirsizlik$ gibi basit bir formül bile karar destek sistemlerinde çok işe yarar.

Metin işleyen bir bot geliştirirken ilk adım, metni normalize etmektir. Büyük-küçük harf farkı, noktalama işaretleri ve gereksiz boşluklar kararları bozabilir. Ardından anahtar kelime, desen veya bağlam sinyalleri çıkarılır. Burada düzenli ifadeler, sözlükler ve puanlama fonksiyonları devreye girer.

Aşağıdaki örnek, müşteri destek mesajlarını basit kurallarla sınıflandırır. Kodun amacı; metindeki sinyalleri analiz edip destek ekibine hangi kuyruğa yönlendirme yapılacağını göstermektir.

import re

RULES = [
    {
        'name': 'Acil sipariş problemi',
        'keywords': ['acil', 'gelmedi', 'kargo'],
        'queue': 'oncelikli_destek',
        'score': 8
    },
    {
        'name': 'İade talebi',
        'keywords': ['iade', 'geri göndermek', 'memnun değilim'],
        'queue': 'iade_ekibi',
        'score': 6
    },
    {
        'name': 'Fatura sorunu',
        'keywords': ['fatura', 'vergi', 'adres'],
        'queue': 'muhasebe',
        'score': 5
    }
]

def normalize(text):
    return re.sub(r'\s+', ' ', text.lower()).strip()

def classify(message):
    text = normalize(message)
    results = []

    for rule in RULES:
        hit_count = sum(1 for word in rule['keywords'] if word in text)
        if hit_count > 0:
            results.append({
                'rule': rule['name'],
                'queue': rule['queue'],
                'final_score': rule['score'] + hit_count
            })

    if not results:
        return {'queue': 'genel_destek', 'reason': 'Eşleşen kural yok'}

    return max(results, key=lambda item: item['final_score'])

print(classify('Kargom gelmedi, acil destek istiyorum.'))

Bu örnekte bot, makine öğrenmesi yapmıyor; fakat kararını açıklayabiliyor. Neden öncelikli destek kuyruğu seçildi? Çünkü metinde acil ve kargo gibi sinyaller bulundu. Gerçek dünyada bu açıklanabilirlik çok değerlidir. Özellikle finans, sağlık, hukuk ve insan kaynakları gibi alanlarda sistemin sadece karar vermesi değil, kararın gerekçesini sunması da gerekir.

Ancak kural tabanlı botların karanlık tarafı da vardır: kural patlaması. Her yeni istisna için yeni bir kural yazıldığında sistem bir süre sonra spagettiye dönebilir. Bu yüzden kurallar kategorilere ayrılmalı, öncelik değerleri net tanımlanmalı ve çakışma yönetimi yapılmalıdır. Örneğin iki kural aynı anda çalışıyorsa en yüksek skor mu seçilecek, yoksa kritik etiket her zaman üstün mü gelecek? Bu kararlar baştan tasarlanmalıdır.

İyi bir mimaride kurallar kodun içine gömülmek yerine JSON, YAML veya veritabanında saklanabilir. Böylece yazılımcı olmayan alan uzmanları da kuralları güncelleyebilir. Ayrıca her karar için günlük kaydı tutulmalıdır: hangi metin geldi, hangi kurallar tetiklendi, sonuç ne oldu? Bu kayıtlar sistemin iyileştirilmesi için altın madeni gibidir.

Sonuç olarak kural tabanlı botlar, teorik mantık ile pratik yazılım mühendisliğinin eğlenceli buluşma noktasıdır. Doğru normalize edilmiş metin, iyi tasarlanmış koşullar, puanlama mantığı ve açıklanabilir karar akışı birleştiğinde küçük ama güçlü otomasyonlar ortaya çıkar. Büyük yapay zeka modellerinin çağında bile, bazen en iyi çözüm hâlâ şudur: açık, okunabilir ve test edilebilir bir kural.

ext4’ün günlükleme mekanizması, özellikle sistem çökmesi veya elektrik kesintisi gibi durumlarda dosya sisteminin tutarlı kalmasını sağlar. Basit fikir şudur: Kritik meta veri değişiklikleri önce “journal” denen özel bir alana yazılır, ardından asıl konumlarına uygulanır. Böylece sistem yarıda kesilirse ext4, günlüğe bakarak işlemi tamamlayabilir veya geri alabilir.

Teorik olarak bunu küçük bir işlem sırası gibi düşünebiliriz:

Burada commit block, “bu işlem grubu tamamlandı” damgası gibidir. ext4 varsayılan olarak genellikle data=ordered kipinde çalışır: dosya verisi asıl yerine yazılır, meta veri ise journal üzerinden güvenceye alınır.

Journal alanı ext4 içinde çoğunlukla özel bir inode olarak tutulur: inode 8. Biz bu inode’un fiziksel bloklarını debugfs ile bulacağız. Bir blok numarası $P$, blok boyutu $B$ ise byte cinsinden konum:

dd komutu bu ofsete gidip blokları okuyacak, hexdump da bize ham içeriği gösterecek.

Önce güvenli bir laboratuvar oluşturalım:

truncate -s 256M ext4-lab.img
mkfs.ext4 -F ext4-lab.img
mkdir -p mnt-lab
sudo mount -o loop ext4-lab.img mnt-lab

Şimdi izleme betiğimiz gelsin. Bu betik imaj dosyasından blok boyutunu öğrenir, journal inode’unun ilk extent’ini bulur ve belirli aralıklarla o bölgeden veri okuyup hexadecimal biçimde gösterir.

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

IMG="${1:-ext4-lab.img}"
BLOCKS_TO_READ="${2:-4}"
INTERVAL="${3:-1}"

if [[ ! -f "$IMG" ]]; then
  echo "İmaj bulunamadı: $IMG" >&2
  exit 1
fi

BS=$(dumpe2fs -h "$IMG" 2>/dev/null | awk -F: '/Block size/ {gsub(/ /,"",$2); print $2}')

JOURNAL_RANGE=$(debugfs -R 'stat <8>' "$IMG" 2>/dev/null \
  | awk '
    match($0, /\):([0-9]+)-([0-9]+)/, a) { print a[1], a[2]; exit }
    match($0, /\):([0-9]+)/, a) { print a[1], a[1]; exit }
  ')

START_BLOCK=$(echo "$JOURNAL_RANGE" | awk '{print $1}')
END_BLOCK=$(echo "$JOURNAL_RANGE" | awk '{print $2}')

if [[ -z "${START_BLOCK:-}" ]]; then
  echo "Journal blokları bulunamadı. debugfs çıktısını kontrol edin." >&2
  exit 1
fi

OFFSET=$((START_BLOCK * BS))

printf "Blok boyutu      : %s byte\n" "$BS"
printf "Journal başlangıcı: blok %s\n" "$START_BLOCK"
printf "Journal bitişi    : blok %s\n" "$END_BLOCK"
printf "Okunan offset     : %s byte\n\n" "$OFFSET"

while true; do
  clear
  date
  echo "Journal bölgesinden $BLOCKS_TO_READ blok okunuyor..."
  dd if="$IMG" bs="$BS" skip="$START_BLOCK" count="$BLOCKS_TO_READ" status=none \
    | hexdump -C | head -n 40
  sleep "$INTERVAL"
done

Kaydedip çalıştırın:

chmod +x watch-ext4-journal.sh
./watch-ext4-journal.sh ext4-lab.img 8 1

Başka bir terminalde dosya sistemine yazma yapalım:

for i in {1..20}; do
  sudo dd if=/dev/urandom of=mnt-lab/file-$i.bin bs=1M count=2 status=none
  sync
  sleep 1
done

İzleme ekranında bazı byte dizilerinin değiştiğini göreceksiniz. Bunlar her zaman “dosya içeriği” değildir; çoğunlukla inode, dizin girdisi, blok bitmap’i gibi meta veri değişikliklerinin journal kayıtlarıdır.

Buradaki önemli nokta şudur: ext4 journal’ı bir metin günlüğü değildir; insanlar için değil, dosya sisteminin kendisi için tasarlanmış ikili bir yapıdır. Yani ekranda anlamlı cümleler değil, işlem kayıtlarının ham temsillerini görürsünüz. Yine de yazma yaptıkça bu alanın değiştiğini izlemek, journal fikrini soyut bir kavram olmaktan çıkarır.

Deney bitince temizleyin:

sudo umount mnt-lab
rmdir mnt-lab
rm ext4-lab.img

Bu küçük proje sayesinde ext4’ün “önce not al, sonra uygula” mantığını canlı gözlemledik. Dosya sistemleri sessiz çalışır; ama doğru araçlarla bakınca oldukça konuşkandırlar.

GDB’nin Python tarafında en sevdiğimiz oyuncular gdb.Command, gdb.selected_inferior() ve read_memory() fonksiyonlarıdır. gdb.Command ile yeni komut tanımlarız, inferior dediğimiz şey debug edilen süreçtir, read_memory() ise belirli adres aralığındaki ham baytları okumamızı sağlar. Linux üzerinde /proc/<pid>/maps dosyasından [stack] satırını okuyarak gerçek yığın sınırlarını yakalayabiliriz.

Aşağıdaki betik stackstrings adlı yeni bir GDB komutu ekler. Minimum uzunluğu parametre olarak verebilir, aksi halde 4 karakterden uzun stringleri listeler. Çıktıda adresler mavi, stringler yeşil renktedir; çünkü debug yaparken biraz neon ışık herkesin hakkı!

# stackstrings.py
import gdb
import string

GREEN = '\033[92m'
BLUE = '\033[94m'
YELLOW = '\033[93m'
RESET = '\033[0m'

PRINTABLE = set(bytes(string.printable, 'ascii')) - {0x0b, 0x0c}

class StackStrings(gdb.Command):
    '''Yığın bölgesindeki yazdırılabilir stringleri bulur: stackstrings [min_len]'''

    def __init__(self):
        super(StackStrings, self).__init__('stackstrings', gdb.COMMAND_DATA)

    def get_stack_range(self):
        inferior = gdb.selected_inferior()
        pid = inferior.pid
        if pid == 0:
            raise gdb.GdbError('Çalışan bir süreç yok. Önce run veya attach kullan.')

        with open(f'/proc/{pid}/maps', 'r') as maps:
            for line in maps:
                if '[stack]' in line:
                    region = line.split()[0]
                    start_s, end_s = region.split('-')
                    return int(start_s, 16), int(end_s, 16)
        raise gdb.GdbError('Stack bölgesi bulunamadı.')

    def invoke(self, arg, from_tty):
        min_len = int(arg) if arg.strip() else 4
        start, end = self.get_stack_range()
        inferior = gdb.selected_inferior()
        mem = inferior.read_memory(start, end - start).tobytes()

        found = 0
        i = 0
        while i < len(mem):
            if mem[i] in PRINTABLE:
                j = i
                while j < len(mem) and mem[j] in PRINTABLE:
                    j += 1
                if j - i >= min_len:
                    raw = mem[i:j]
                    text = raw.decode('ascii', errors='replace')
                    addr = start + i
                    print(f'{BLUE}0x{addr:x}{RESET}: {GREEN}{text}{RESET}')
                    found += 1
                i = j
            else:
                i += 1

        print(f'{YELLOW}Toplam {found} string bulundu. Aralık: 0x{start:x}-0x{end:x}{RESET}')

StackStrings()

Kullanmak için betiği kaydedip GDB içinde yüklemek yeterli:

gdb ./program
(gdb) run
(gdb) source stackstrings.py
(gdb) stackstrings 6

Buradaki algoritma oldukça basittir: belleği soldan sağa tarar, karakter PRINTABLE kümesindeyse bir koşu başlatır, koşu uzunluğu minimum değeri geçerse sonuç üretir. Zaman karmaşıklığı \(O(N)\), bellek maliyeti ise okunan yığın kadar yani \(O(N)\) kabul edilir. Büyük yığınlarda parça parça okuma yapılabilir; fakat öğretici olması için tek parça okuma daha anlaşılırdır.

Bu komut özellikle CTF, tersine mühendislik, exploit geliştirme ve “ben bu değişkene ne zaman ne yazdım?” soruşturmasında işe yarar. Yine de dikkat: Stack içinde gördüğünüz her karakter dizisi anlamlı string değildir. Rastgele baytlar bazen tesadüfen okunabilir karakterlere dönüşebilir. Bu yüzden bulunan sonuçları bağlamla, register’larla ve backtrace ile birlikte değerlendirmek gerekir.

Sonuç olarak GDB’nin Python API’si, debugger’ı kişisel bir analiz laboratuvarına çevirir. Bugün stack stringlerini renklendirdik; yarın heap tarayıcı, otomatik breakpoint raporlayıcı ya da şüpheli pointer avcısı yazabilirsiniz. Debug dünyasında büyüteç sizde, Python ise büyütecin LED ışığıdır.