BERK Programlama Dili

BERK, dünyada ilk kez gerçek çift dilli syntax (Türkçe/İngilizce) ile tasarlanmış, modern, güvenli ve yüksek performanslı bir sistem programlama dilidir. 19 farklı hedef platformda (masaüstü, mobil, gömülü, WebAssembly) üretkenlik sağlar.

📖 Neden BERK Adı Seçilmiştir?

Öztürkçe Kökeni: "Güçlü, Muhkem, Sağlam"

BERK kelimesi, Öztürkçe'de "güçlü, dayanıklı, muhkem ve sağlam" anlamlarına gelir. Bu nitelikler, programlama dilinin teknik hedefleriyle doğrudan örtüşmektedir: bellek güvenliği, tip sistemi doğruluğu, güçlü derleyici mimarisi ve kararlı performans.

Arapçadan Gelen Anlamı: "Şimşek"

Türkçe'de karşılık bulan bir diğer anlam **"şimşek"**tir. Bu anlam, BERK dilinin hız, performans ve çeviklik vizyonunu temsil eder: LLVM tabanlı hızlı derleme, C++ seviyesinde performans ve optimize edilmiş çekirdek mimarisi.

Anlamların Birleşimi

BERK, hem Türkçe kökenli sağlamlık kavramını hem de modern teknoloji dünyasındaki hız ve çeviklik kavramlarını birleştirerek güçlü bir marka kimliği oluşturur.

Uluslararası Alanda

BERK, Beyond-Efficient Runtime Kernel (Verimliliğin Ötesinde Çalışma Zamanı Çekirdeği) olarak tanımlanacaktır.

📥 İndirme ve Kurulum

Windows x64 (v0.8.0)

Son Sürüm: BERK v0.8.0 (19 Kasım 2025)
Boyut: ~25 MB
Platform: Windows 10/11 (64-bit)

🔗 İndirme Linkleri

• ⬇️ BERK-lang.exe İndir - Derleyici
• 📚 Dokümantasyon (PDF) - Tam Rehber
• 📖 Çevrimiçi Kitapçık - Etkileşimli Dokümantasyon

Kurulum

# 1. BERK-lang.exe'yi indirin
# 2. İstediğiniz bir klasöre kopyalayın (örn: C:\BERK)
# 3. PATH'e ekleyin:
$env:PATH += ";C:\BERK"

# Test edin
BERK-lang --version

Hızlı Başlangıç

Seçenek 1: Etkileşimli REPL (Anında Test)

# REPL'i başlatın
BERK-lang repl

# Kod yazın ve Enter'a basın - anında çalışır!
>>> yazdır("Merhaba, BERK!")
Merhaba, BERK!

>>> değişken x = 5 + 3
>>> yazdır(x * 2)
16

Seçenek 2: Derleme (Native Executable)

# İlk programınızı yazın (merhaba.berk)
fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba, BERK!")
    dön 0
son

# LLVM ile native kod üretin
BERK-lang compile merhaba.berk -o merhaba.exe

# Çalıştırın (artık bağımsız executable)
.\merhaba.exe

Seçenek 3: JIT Çalıştırma (Derleme + Çalıştırma)

# Direkt çalıştır (arka planda LLVM JIT)
BERK-lang run merhaba.berk

Diğer Platformlar

Linux ve macOS: Kaynak koddan derleme gereklidir.

# Rust toolchain kurulumu
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# BERK'u derleyin
git clone https://github.com/ArslantasM/berk
cd berk/berk-lang
cargo build --release --features llvm

🌟 BERK'i Özel Kılan Özellikler

🌍 Dünyada İlk: Gerçek Çift Dilli Syntax

Programlama dillerinde ilk kez, aynı derleyicide hem Türkçe hem İngilizce anahtar kelimelerle kod yazabilirsiniz. Bu sadece bir çeviri değil, dilin özünde bulunan bir özelliktir.

⚡ C/C++/Rust Seviyesinde Performans

• LLVM Backend: Native kod üretimi ile sıfır maliyet abstraksiyonlar
• Benchmark Sonuçları: C++ ile %98-100 performans eşitliği
• Memory Efficiency: Manuel kontrol + güvenlik garantileri
• Optimizasyon Seviyeleri: O0-O3 arası agresif optimizasyon

🧠 Rules-Based AI Yaklaşımı

Derleyici, kural tabanlı yapay zeka teknikleri kullanarak:

• Akıllı hata tespiti ve öneriler
• Kod optimizasyon kararları
• Tip çıkarımı ve analiz
• Semantic analysis ile kalite garantisi

🔬 Bilimsel Hesaplama Kütüphaneleri (stdlib v1.4)

18 modül, 600+ fonksiyon, 285 KB kod:

• linalg: Matrix işlemleri, LU/QR/Cholesky decomposition, eigenvalue
• stats: İstatistik, regresyon, hipotez testleri, dağılımlar
• optim: Gradient descent, BFGS, simulated annealing
• NumPy/SciPy/Julia seviyesinde bilimsel hesaplama

🚀 19 Farklı Hedef Platform

Cross-compilation desteği:

• Desktop: Windows (x64/ARM), Linux (x64/ARM), macOS (Intel/Apple Silicon)
• Embedded: ARM Cortex-M, RISC-V, AVR, ESP32
• Mobile: Android (ARM/x86), iOS (ARM64)
• WebAssembly: Tarayıcı ve sunucu
• Cloud: AWS Lambda, Azure Functions uyumlu

📚 Son Derece Kolay Öğrenme

• Sezgisel Syntax: Python'un basitliği + Rust'ın gücü
• Türkçe Dokümantasyon: 70+ sayfa kapsamlı rehber
• Anlaşılır Hata Mesajları: Çözüm önerileriyle
• Öğrenme Eğrisi: 1-2 hafta ile productive olma

🔧 Gömülü Sistem Kabiliyeti

• Bare-metal programlama desteği
• RTOS entegrasyonu (FreeRTOS, Zephyr)
• Low-level donanım erişimi
• Interrupt handling ve DMA desteği
• Minimal runtime: 2-5 KB overhead

Neden BERK?

🎯 Akademisyenler ve Araştırmacılar İçin

• Bilimsel Hesaplama: NumPy/SciPy/MATLAB seviyesinde kütüphaneler
• Performans: C++ hızında, Python kolaylığında
• Reproducibility: Deterministik derleme, reproducible builds
• Publishing: Türkçe akademik yayınlar için ideal

💼 Sektör Profesyonelleri İçin

• Production-Ready: C/C++/Rust ile yarışabilir performans
• Cross-Platform: Tek kod tabanı, 19 platform
• Maintainability: Okunabilir kod, kolay refactoring
• Interoperability: C/C++ FFI, mevcut sistemlere entegrasyon
• Cost-Effective: Daha az bug, daha hızlı development

🎓 Eğitimciler ve Öğrenciler İçin

• Türkçe İçerik: Anadilde programlama öğrenimi
• Modern Kavramlar: Type safety, pattern matching, error handling
• Kolay Geçiş: Python'dan gelen için doğal, C++'a geçiş için köprü
• Pratik Örnekler: Gerçek dünya uygulamaları

1. Dünyada İlk: Gerçek Çift Dilli Syntax

// Türkçe
fonksiyon selamla(isim: yazı) -> yazı
yap
    dön "Merhaba, " + isim + "!"
son

// English (aynı derleyici!)
function greet(name: string) -> string
do
    return "Hello, " + name + "!"
end

// Karışık kullanım bile mümkün
function hesapla(sayı: tamsayı) -> tamsayı
yap
    eğer sayı > 0
        return sayı * 2
    değilse
        dön 0
    son
son

2. Modern ve Güvenli

• ✅ Güçlü tip sistemi
• ✅ Bellek güvenliği
• ✅ Null safety
• ✅ Pattern matching
• ✅ Error handling

3. Yüksek Performans + LLVM Backend

• Native kod üretimi - C++ ile %98-100 performans eşitliği
• 19 farklı mimari desteği (x64, ARM, RISC-V, WebAssembly, ...)
• Optimizasyon seviyeleri (O0-O3)
• Cross-compilation - tek kod, 19 platform
• Zero-cost abstractions
• Inline assembly desteği

4. Bilimsel Hesaplama (stdlib v1.4)

import linalg, stats, optim

// Linear Algebra
değişken A = linalg.matris_oluştur([[1, 2], [3, 4]])
değişken B = linalg.matris_çarp(A, linalg.transpose(A))
değişken (L, U) = linalg.lu_ayrıştır(A)

// İstatistik
değişken veri = [1.2, 2.3, 3.4, 4.5, 5.6]
değişken ort = stats.ortalama(veri)
değişken std = stats.standart_sapma(veri)
değişken (r, p) = stats.korelasyon(x, y)

// Optimizasyon
değişken minimum = optim.gradient_descent(fonksiyon, x0, öğrenme=0.01)
değişken sonuç = optim.bfgs(maliyet, başlangıç)

4. Geliştirici Dostu

• Kapsamlı dokümantasyon (70+ sayfa, Türkçe)
• Anlaşılır hata mesajları (çözüm önerileriyle)
• VS Code eklentisi (syntax highlighting, autocomplete, debugging)
• REPL (etkileşimli kabuk) - anında test
• Zengin test altyapısı
• Kolay öğrenme: 1-2 hafta ile productive

Hızlı Başlangıç

Kurulum

# Rust toolchain gerekli
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# BERK'u derle
git clone https://github.com/ArslantasM/berk
cd berk/berk-lang
cargo build --release --features llvm

# PATH'e ekle
export PATH="$PWD/target/release:$PATH"

İlk Programınız

// merhaba.berk
fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba, BERK!")
    dön 0
son

# Derle ve çalıştır
BERK-lang merhaba.berk -o merhaba.exe
./merhaba.exe
# Çıktı: Merhaba, BERK!

Bu Kitap Hakkında

Bu kitap, BERK programlama dilini öğrenmek için kapsamlı bir kaynaktır. Rust Book ve Python Documentation gibi kaynakların en iyi yanlarını bir araya getirerek hazırlanmıştır.

Hedef Kitle

• Programlamaya yeni başlayanlar
• Deneyimli geliştiriciler
• Sistem programcıları
• Türkçe içerik arayan geliştiriciler

Kitabı Nasıl Kullanmalısınız?

1. Sıralı Okuma: Baştan sona sırayla okumanızı öneririz
2. Örnekleri Deneyin: Her örneği kendi bilgisayarınızda çalıştırın
3. Alıştırmalar: Her bölümün sonundaki alıştırmaları yapın
4. Referans: İhtiyaç duyduğunuzda referans bölümlerine dönün

Dil Felsefesi

BERK'un temel tasarım ilkeleri:

1. Erişilebilirlik

Türkçe anahtar kelimeler sayesinde, İngilizce bilmeyenler için programlamaya giriş kolaylaştırılmıştır.

2. Güvenlik

Bellek hatalarını derleme zamanında yakalar. Runtime hatalarını minimize eder.

3. Performans

LLVM backend sayesinde C/C++ seviyesinde performans sunar.

4. Okunabilirlik

Açık ve anlaşılır syntax. Kod yazmaktan çok kod okumaya optimize edilmiştir.

5. İnterop

C/C++ kütüphaneleriyle uyumlu. Mevcut ekosistemlere entegre olabilir.

Öne Çıkan Özellikler

Modern Type System

değişken x: tamsayı = 42
değişken isim: yazı = "Ahmet"
değişken aktif: mantıksal = doğru
değişken sayılar: liste<tamsayı> = [1, 2, 3]
değişken nokta: demet<tamsayı, tamsayı> = (10, 20)

Pattern Matching

seç durum mesaj
    durum "başarılı":
        yazdır("İşlem tamamlandı!")
    durum "hata":
        yazdır("Bir hata oluştu!")
    durum _:
        yazdır("Bilinmeyen durum")
son

String İşlemleri (UTF-8)

değişken mesaj = "Merhaba Dünya! 🌍"
değişken uzunluk = uzunluk(mesaj)
değişken birleşik = "Hello " + "World"

Hata Yönetimi

dene
    değişken dosya = aç("data.txt")
    yazdır(oku(dosya))
yakala hata
    yazdır("Dosya açılamadı: " + hata)
son

Derleyici Mimarisi

BERK derleyicisi modern bir yapıya sahiptir:

Kaynak Kod (.berk)
    ↓
Lexer (Token Üretimi)
    ↓
Parser (AST Oluşturma)
    ↓
Semantic Analysis (Tip Kontrolü)
    ↓
CFG Analysis (Dataflow Analysis)
    ↓
IR Generation (BERK IR)
    ↓
IR Optimization (O0-O3)
    ↓
LLVM IR Generation
    ↓
Machine Code (.exe/.o)

Proje Durumu

Mevcut Sürüm: v0.8.0-dev
Son Güncelleme: 18 Kasım 2025
Durum: Active Development

Tamamlanan Özellikler ✅

• Lexer & Parser (100%)
• Type System (100%)
• LLVM Backend (100%)
• CFG Analysis (100%)
• IR Optimizer (100%)
• REPL (100%)
• VS Code Extension (100%)

Devam Eden Çalışmalar

• Runtime Library
• Standard Library
• Package Manager
• Debugger Integration

Detaylı yol haritası için Roadmap sayfasına bakın.

Topluluk ve Katkı

BERK açık kaynak bir projedir ve katkılara açıktır!

• GitHub: ArslantasM/berk
• Issues: Bug raporları ve özellik istekleri
• Discussions: Topluluk tartışmaları
• Contributing: Katkıda bulunma rehberi

Ek Kaynaklar

• GitHub Repository
• VS Code Extension
• CHANGELOG
• FAQ

Hazır mısınız? Kurulum bölümünden başlayalım!

Kurulum

Bu bölümde BERK programlama dilini sisteminize nasıl kuracağınızı öğreneceksiniz.

Gereksinimler

Windows

• Windows 10/11 (64-bit)
• Rust toolchain (1.70+)
• Visual Studio Build Tools 2022
• LLVM 17.0.6
• Git
• Minimum 8GB RAM (derleme için)

Linux

• Ubuntu 20.04+ / Debian 11+ / Fedora 35+
• Rust toolchain (1.70+)
• GCC/Clang compiler
• LLVM 17.0.6
• Git
• Minimum 4GB RAM

macOS

• macOS 11 (Big Sur) veya üzeri
• Rust toolchain (1.70+)
• Xcode Command Line Tools
• LLVM 17.0.6 (Homebrew)
• Git
• Minimum 4GB RAM

Rust Kurulumu

BERK, Rust ile yazılmıştır. Önce Rust'ı kurmanız gerekir:

Windows/Linux/macOS

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Kurulum sonrası:

rustc --version
cargo --version

Çıktı:

rustc 1.75.0 (1.75.0 2024-01-01)
cargo 1.75.0 (1.75.0 2024-01-01)

LLVM Kurulumu

BERK, native kod üretimi için LLVM 17 kullanır.

Windows (Ön-derlenmiş)

1. LLVM 17.0.6 İndir:

   • LLVM Releases
   • LLVM-17.0.6-win64.exe dosyasını indirin

2. Kur:

   • Installer'ı çalıştırın
   • "Add LLVM to system PATH" seçeneğini işaretleyin
   • Kurulum yolu: C:\Program Files\LLVM (varsayılan)

3. Doğrula:

   llvm-config --version
   

Windows (Kaynak Koddan)

Detaylı kurulum için: LLVM_SETUP.md

# LLVM kaynak kodunu indir
git clone --depth 1 --branch llvmorg-17.0.6 https://github.com/llvm/llvm-project.git

# Build dizini oluştur
cd llvm-project
mkdir build
cd build

# CMake yapılandırması
cmake -G Ninja ../llvm `
  -DCMAKE_BUILD_TYPE=Release `
  -DLLVM_TARGETS_TO_BUILD=all `
  -DCMAKE_INSTALL_PREFIX=C:\llvm-17

# Derle (2-3 saat sürebilir)
ninja
ninja install

Linux (Ubuntu/Debian)

# LLVM 17 repository ekle
wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 17

# Gerekli paketler
sudo apt install llvm-17-dev libllvm17 llvm-17-tools clang-17

Linux (Fedora)

sudo dnf install llvm17-devel llvm17-libs clang17

macOS (Homebrew)

brew install llvm@17

# PATH'e ekle
echo 'export PATH="/opt/homebrew/opt/llvm@17/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

LLVM Environment Variables

Kurulum sonrası environment variable'ları ayarlayın:

Windows (PowerShell):

$env:LLVM_SYS_170_PREFIX = "C:\llvm-17"
[Environment]::SetEnvironmentVariable("LLVM_SYS_170_PREFIX", "C:\llvm-17", "User")

Linux/macOS (Bash/Zsh):

export LLVM_SYS_170_PREFIX=/usr/lib/llvm-17
echo 'export LLVM_SYS_170_PREFIX=/usr/lib/llvm-17' >> ~/.bashrc

BERK Kurulumu

Method 1: Pre-built Binary (Windows - Önerilen) ⚡

Windows x64 kullanıcıları için en hızlı yol:

1. İndir:

   • 🔗 BERK-lang.exe (83 MB)
   • Tek dosya, tüm bağımlılıklar dahil (LLVM statik linkli)

2. Kur:

   # İstediğiniz bir klasöre kopyalayın
   New-Item -ItemType Directory -Path C:\BERK -Force
   Move-Item .\BERK-lang.exe C:\BERK\
   
   # PATH'e ekleyin
   [Environment]::SetEnvironmentVariable(
       "Path",
       [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\BERK",
       "User"
   )
   
   # Yeni terminal açın ve test edin
   BERK-lang --version
   

3. Hızlı Test:

   # REPL ile anında test
   BERK-lang repl
   >>> yazdır("Merhaba!")
   Merhaba!
   

Özellikler:

• ✅ LLVM 17 statik linkli - harici bağımlılık yok
• ✅ Tüm 19 hedef platform desteği
• ✅ REPL, JIT run, ve native compile modu
• ✅ Runtime kütüphaneleri dahil (JSON, Crypto, HTTP)

Not: LLVM statik linking nedeniyle dosya 83 MB'tır.

Method 2: Kaynak Koddan (Tüm Platformlar)

Linux/macOS veya özelleştirme isteyenler için:

# Repository'yi klonla
git clone https://github.com/ArslantasM/berk.git
cd berk/berk-lang

# LLVM feature ile derle
cargo build --release --features llvm

# Test et
cargo test --features llvm

# Binary'yi PATH'e ekle (Linux/macOS)
sudo ln -s $(pwd)/target/release/BERK-lang /usr/local/bin/BERK-lang

# Binary'yi PATH'e ekle (Windows)
# target\release\BERK-lang.exe dosyasını PATH'teki bir dizine kopyalayın

Derleme Süresi: ~40 saniye (release build)

Method 3: Cargo Install (Gelecek)

# Planlanan özellik
cargo install BERK-lang --features llvm

Kurulum Doğrulama

Kurulumun başarılı olduğunu doğrulayın:

# Derleyici versiyonu
BERK-lang --version

Çıktı:

🚀 BERK Derleyici v0.8.0
   LLVM 17.0.6 (19 Target Support)

Hızlı Test: REPL

En hızlı yol - REPL kullanın:

BERK-lang repl

REPL'de test edin:

>>> yazdır("Kurulum başarılı! 🎉")
Kurulum başarılı! 🎉

>>> değişken x = 42
>>> yazdır(x * 2)
84

>>> fonksiyon kare(n: tamsayı) -> tamsayı { dön n * n }
>>> yazdır(kare(5))
25

Çıkmak için: :quit veya Ctrl+C

Test Programı (Derleme)

Dosyadan çalıştırma:

test.berk:

fonksiyon ana() -> tamsayı
yap
    yazdır("Kurulum başarılı! 🎉")
    dön 0
son

Seçenek 1: JIT çalıştırma (hızlı)

BERK-lang run test.berk

Seçenek 2: Native derleme

BERK-lang compile test.berk -o test.exe
./test.exe

Her iki durumda çıktı:

Kurulum başarılı! 🎉

VS Code Eklentisi (Opsiyonel)

VS Code kullanıyorsanız, BERK eklentisini kurun:

Method 1: Marketplace (Yakında)

VS Code → Extensions → "BERK" ara → Install

Method 2: Manuel Kurulum

cd berk/berk-vscode
npm install
npm run compile
code --install-extension BERK-lang-0.1.0.vsix

Özellikler:

• Syntax highlighting
• Code snippets
• Intellisense (basic)
• Run/Debug commands
• Status bar integration

REPL Kullanımı

REPL (Read-Eval-Print Loop) ana derleyici ile birlikte gelir:

# REPL'i başlat
BERK-lang repl

REPL Komutları

BERK> :help

Kullanılabilir komutlar:
  :quit, :q      - REPL'den çık
  :help, :h      - Yardım göster
  :clear, :c     - Ekranı temizle
  :history       - Komut geçmişi
  :lang <tr|en>  - Dil değiştir (Türkçe/English)
  :type <expr>   - İfadenin tipini göster

REPL Örnekleri

Basit hesaplamalar:

>>> 5 + 3
8

>>> 10 * 2.5
25.0

Değişkenler:

>>> değişken isim = "BERK"
>>> yazdır("Merhaba, " + isim)
Merhaba, BERK

Fonksiyonlar:

>>> fonksiyon topla(a: tamsayı, b: tamsayı) -> tamsayı { dön a + b }
>>> topla(10, 20)
30

Dil değiştirme:

>>> :lang en
Language switched to English

>>> function hello(name: string) { print("Hello, " + name) }
>>> hello("World")
Hello, World

>>> :lang tr
Dil Türkçe'ye değiştirildi

Sorun Giderme

LLVM Bulunamıyor

Hata:

error: could not find native static library `LLVM-17`

Çözüm:

# LLVM_SYS_170_PREFIX doğru ayarlı mı?
echo $LLVM_SYS_170_PREFIX  # Linux/macOS
echo $env:LLVM_SYS_170_PREFIX  # Windows

# LLVM kurulu mu?
llvm-config --version

Cargo Build Hatası

Hata:

error: linker `link.exe` not found

Çözüm (Windows):

• Visual Studio Build Tools 2022 kurulu olmalı
• "Desktop development with C++" workload seçili olmalı

Yavaş Derleme

İpuçları:

# Parallel build (4 core)
cargo build --release --features llvm -j4

# Incremental compilation
export CARGO_INCREMENTAL=1

# Daha az optimization (debug build)
cargo build --features llvm

macOS ARM (M1/M2) Sorunları

# Rosetta 2 kurulumu
softwareupdate --install-rosetta

# ARM native LLVM
brew install llvm@17

# Architecture kontrol
arch
# Çıktı: arm64

Ek Kurulum Adımları

Debugger (Gelecek)

# GDB (Linux)
sudo apt install gdb

# LLDB (macOS)
xcode-select --install

Profiler (Gelecek)

# Valgrind (Linux)
sudo apt install valgrind

# Instruments (macOS)
# Xcode ile birlikte gelir

Kurulum Tamamlandı!

Artık BERK ile kod yazmaya hazırsınız!

Sonraki Adım: Merhaba Dünya! programınızı yazın

Yardım ve Destek

Sorun mu yaşıyorsunuz?

• FAQ - Sık sorulan sorular
• GitHub Issues - Bug raporları
• Discussions - Topluluk yardımı
• Email: BERK-support@example.com

Önceki: Giriş | Sonraki: Merhaba Dünya!

Merhaba Dünya!

Her programlama dilinde gelenek, ilk programın "Merhaba Dünya!" yazdırması olmuştur. BERK'ta da bu geleneği sürdürüyoruz!

İlk Programınız

Favori metin editörünüzde merhaba.berk adında bir dosya oluşturun:

fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba Dünya!")
    dön 0
son

Kodu Anlayalım

Satır satır inceleyelim:

1. Fonksiyon Tanımı

fonksiyon ana() -> tamsayı

• fonksiyon (veya function): Fonksiyon tanımlar
• ana (veya main): Fonksiyonun adı. Program ana() fonksiyonundan başlar
• (): Parametre listesi (boş)
• -> tamsayı: Dönüş tipi (integer)

2. Fonksiyon Gövdesi

yap
    ...
son

• yap (veya do): Fonksiyonun başlangıcı
• son (veya end): Fonksiyonun bitişi

3. Yazdırma

yazdır("Merhaba Dünya!")

• yazdır() (veya print()): Ekrana yazdırır
• "Merhaba Dünya!": String literal

4. Dönüş Değeri

dön 0

• dön (veya return): Fonksiyondan çıkış
• 0: Başarılı programlar 0 döner (Unix geleneği)

Derleme ve Çalıştırma

Adım 1: Derleme

BERK-lang merhaba.berk -o merhaba.exe

Çıktı:

🚀 BERK Derleyici v0.8.0-dev
   LLVM 17.0.6 (19 Target Support)
=========================================
📂 Giriş: merhaba.berk
📤 Çıkış: merhaba.exe
🎯 Emit: Executable
⚡ Optimizasyon: O0
=========================================

✅ Derleme başarılı!

Adım 2: Çalıştırma

Windows:

.\merhaba.exe

Linux/macOS:

./merhaba

Çıktı:

Merhaba Dünya!

İngilizce Versiyonu

BERK iki dilli! Aynı programı İngilizce de yazabilirsiniz:

hello.berk:

function main() -> integer
do
    print("Hello World!")
    return 0
end

Derleme:

BERK-lang hello.berk -o hello.exe
./hello.exe

Çıktı:

Hello World!

Karışık Kullanım

Hatta Türkçe ve İngilizce'yi karıştırabilirsiniz:

function ana() -> tamsayı
yap
    print("Hello Dünya!")
    return 0
son

Bu da geçerli bir BERK kodudur!

Derleme Seçenekleri

Verbose Mode

Derleme adımlarını görmek için:

BERK-lang merhaba.berk -o merhaba.exe -v

Çıktı:

🔍 Dil tanıma...
✅ Turkish detected (100.0% confidence)

🌳 AST oluşturuluyor...
✅ 1 ifade parse edildi

🧠 Akıllı analiz (Rules Engine)...
✅ Analiz tamamlandı

🔍 Tip kontrolü...
✅ Tip kontrolü başarılı

🔧 IR üretimi...
✅ IR üretildi

🎯 LLVM IR üretimi...
✅ Object file: merhaba.o

🔗 Linking...
✅ Executable oluşturuldu: merhaba.exe

🎊 Derleme başarılı!

Optimizasyon Seviyeleri

O0 - Optimizasyon yok (varsayılan):

BERK-lang merhaba.berk -o merhaba_o0.exe -O0

O1 - Temel optimizasyonlar:

BERK-lang merhaba.berk -o merhaba_o1.exe -O1

O2 - Orta seviye (önerilen):

BERK-lang merhaba.berk -o merhaba_o2.exe -O2

O3 - Agresif optimizasyonlar:

BERK-lang merhaba.berk -o merhaba_o3.exe -O3

Farklı Çıktı Formatları

LLVM IR göster:

BERK-lang merhaba.berk --emit llvm-ir

Assembly göster:

BERK-lang merhaba.berk --emit asm

IR göster:

BERK-lang merhaba.berk --emit ir

REPL'de Deneme

Etkileşimli kabukta da deneyebilirsiniz:

BERK-repl

BERK> yazdır("Merhaba REPL!")
Merhaba REPL!
=> Result: Void

BERK> 1 + 2
=> Result: Integer = 3

BERK> :quit
Güle güle!

Alıştırmalar

Alıştırma 1: Kişiselleştirme

Programı kendi adınızı yazdıracak şekilde değiştirin:

fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba, [ADINIZ]!")
    dön 0
son

Alıştırma 2: Çoklu Yazdırma

Birden fazla satır yazdırın:

fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba Dünya!")
    yazdır("BERK'a hoş geldiniz!")
    yazdır("İyi kodlamalar!")
    dön 0
son

Alıştırma 3: Değişken Kullanımı

String'i bir değişkende saklayın:

fonksiyon ana() -> tamsayı
yap
    değişken mesaj = "Merhaba Dünya!"
    yazdır(mesaj)
    dön 0
son

Alıştırma 4: String Birleştirme

İki string'i birleştirin:

fonksiyon ana() -> tamsayı
yap
    değişken selamlama = "Merhaba"
    değişken isim = "Ahmet"
    yazdır(selamlama + ", " + isim + "!")
    dön 0
son

Yaygın Hatalar

Hata 1: Noktalı Virgül Yok

BERK'ta noktalı virgül gerekmez:

// ❌ Yanlış
yazdır("Merhaba");

// ✅ Doğru
yazdır("Merhaba")

Hata 2: Parantez Eksikliği

// ❌ Yanlış
yazdır "Merhaba"

// ✅ Doğru
yazdır("Merhaba")

Hata 3: ana() Fonksiyonu Yok

// ❌ Yanlış - ana() fonksiyonu yok
yazdır("Merhaba")

// ✅ Doğru - ana() fonksiyonu var
fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba")
    dön 0
son

Hata 4: Dönüş Değeri Eksik

// ❌ Yanlış - return eksik
fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba")
son

// ✅ Doğru - return var
fonksiyon ana() -> tamsayı
yap
    yazdır("Merhaba")
    dön 0
son

Sonraki Adımlar

Tebrikler! İlk BERK programınızı yazdınız!

Şimdi daha fazlasını öğrenmeye hazırsınız:

1. İlk Programınızı Yazmak - Daha karmaşık bir program
2. Değişkenler ve Sabitler - Veri saklama
3. Veri Tipleri - Tipler hakkında daha fazla

Özet

Bu bölümde öğrendikleriniz:

• ✅ Basit bir BERK programı yazmak
• ✅ Program derlemek ve çalıştırmak
• ✅ fonksiyon, yap, son anahtar kelimeleri
• ✅ yazdır() fonksiyonu
• ✅ dön statement
• ✅ İki dilli syntax kullanımı
• ✅ Yaygın hatalar ve çözümleri

Önceki: Kurulum | Sonraki: İlk Programınızı Yazmak

İlk Programınızı Yazmak

BERK dilinde basit bir hesaplama programı yazarak başlayalım. Bu örnekte kullanıcıdan iki sayı alıp, çeşitli matematiksel işlemler yapacağız.

Örnek: Hesap Makinesi

hesapla.berk adında yeni bir dosya oluşturun:

// İki dilli syntax desteği - Türkçe anahtar kelimelerle
işlev topla(a: Sayı, b: Sayı) -> Sayı {
    geri dön a + b
}

işlev çıkar(a: Sayı, b: Sayı) -> Sayı {
    geri dön a - b
}

işlev çarp(a: Sayı, b: Sayı) -> Sayı {
    geri dön a * b
}

işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
    eğer b == 0 {
        hata dön "Sıfıra bölme hatası!"
    }
    tamam dön a / b
}

// Ana fonksiyon
işlev ana() {
    değişken x = 10.0
    değişken y = 3.0
    
    yazdır("x = ", x)
    yazdır("y = ", y)
    yazdır("")
    
    yazdır("Toplam: ", topla(x, y))
    yazdır("Fark: ", çıkar(x, y))
    yazdır("Çarpım: ", çarp(x, y))
    
    // Hata yönetimi ile bölme
    değişken sonuç = böl(x, y)
    eş sonuç {
        Tamam(değer) => yazdır("Bölüm: ", değer),
        Hata(mesaj) => yazdır("HATA: ", mesaj)
    }
}

İngilizce Syntax ile Aynı Program

BERK'in avantajı iki dilli syntax desteğidir. Aynı programı İngilizce anahtar kelimelerle de yazabilirsiniz:

function add(a: Number, b: Number) -> Number {
    return a + b
}

function divide(a: Number, b: Number) -> Result<Number, String> {
    if b == 0 {
        error return "Division by zero!"
    }
    ok return a / b
}

function main() {
    var x = 10.0
    var y = 3.0
    
    print("Sum: ", add(x, y))
    
    var result = divide(x, y)
    match result {
        Ok(value) => print("Result: ", value),
        Error(msg) => print("ERROR: ", msg)
    }
}

Programı Çalıştırma

# Doğrudan çalıştır
berk run hesapla.berk

# Derleyip çalıştır
berk build hesapla.berk -o hesapla.exe
./hesapla.exe

Beklenen Çıktı

x = 10
y = 3

Toplam: 13
Fark: 7
Çarpım: 30
Bölüm: 3.333333

Bir Sonraki Adım

Artık temel syntax'a aşina olduğunuza göre, Temel Kavramlar bölümüyle devam edebilirsiniz. Burada değişkenler, veri tipleri ve operatörler hakkında detaylı bilgi bulacaksınız.

Sözdizimi ve Yapı

BERK programlama dilinin temel syntax kuralları ve kod yapısı.

Temel Yapı

Her BERK programı bir ana() (veya main()) fonksiyonundan başlar:

işlev ana() {
    yazdır("Merhaba Dünya!")
}

İngilizce syntax:

function main() {
    print("Hello World!")
}

İfade Sonlandırıcılar

BERK'te ifadeler noktalı virgül gerektirmez. Her satır bir ifade olarak değerlendirilir:

değişken x = 10
değişken y = 20
değişken toplam = x + y
yazdır(toplam)

Çok satırlı ifadelerde backslash kullanabilirsiniz:

değişken uzunMetin = "Bu çok uzun bir yazı \
                      birden fazla satıra yayılıyor"

Blok Yapıları

Bloklar süslü parantez ile tanımlanır:

işlev hesapla() {
    değişken a = 5
    değişken b = 3
    
    eğer a > b {
        yazdır("a büyük")
    } değilse {
        yazdır("b büyük veya eşit")
    }
}

İsimlendirme Kuralları

Değişkenler ve Fonksiyonlar

• snake_case (önerilen): değişken kullanıcı_adı = "Ahmet"
• camelCase (alternatif): değişken kullanıcıAdı = "Ahmet"

Sabitler

• SCREAMING_SNAKE_CASE: sabit MAX_DEĞER = 100

Türler

• PascalCase: tür KullanıcıBilgisi = struct { ... }

// İyi örnekler
değişken sayaç = 0
değişken toplam_fiyat = 99.99
sabit PI_DEĞERI = 3.14159

işlev hesapla_alan(yarıçap: Sayı) -> Sayı {
    geri dön PI_DEĞERI * yarıçap * yarıçap
}

// Kaçınılması gerekenler
değişken s = 0              // Çok kısa, anlaşılmaz
değişken ÖzelSayı123 = 5    // Karışık format

Girinti (Indentation)

BERK girinti konusunda esnek olmakla birlikte, 4 boşluk kullanımı önerilir:

işlev kontrol_et(x: Sayı) {
    eğer x > 0 {
        yazdır("Pozitif")
        eğer x > 100 {
            yazdır("Çok büyük!")
        }
    } değilse eğer x < 0 {
        yazdır("Negatif")
    } değilse {
        yazdır("Sıfır")
    }
}

Boşluklar (Whitespace)

Operatörler etrafında boşluk kullanımı okunabilirliği artırır:

// Tercih edilen
değişken sonuç = a + b * c

// Geçerli ama okunabilir değil
değişken sonuç=a+b*c

Satır Uzunluğu

80-100 karakter sınırı önerilir. Uzun satırları şöyle bölebilirsiniz:

değişken çokUzunDeğişken = birinciFonksiyon(parametere1, parametre2)
                            + ikinciFonksiyon(parametre3)
                            + üçüncüFonksiyon(parametre4)

İki Dilli Syntax

BERK'in en önemli özelliği iki dilli syntax desteğidir. Türkçe ve İngilizce anahtar kelimeleri karıştırabilirsiniz:

// Tamamen Türkçe
işlev hesapla(x: Sayı) -> Sayı {
    eğer x < 0 {
        hata dön "Negatif sayı!"
    }
    geri dön x * x
}

// Tamamen İngilizce
function calculate(x: Number) -> Number {
    if x < 0 {
        error return "Negative number!"
    }
    return x * x
}

// Karışık (geçerli ama önerilmez)
function hesapla(x: Sayı) -> Number {
    if x < 0 {
        hata dön "Negative!"
    }
    return x * x
}

Best Practice: Projenizde tek bir dil tercih edin (Türkçe VEYA İngilizce).

Modüller

Her dosya bir modül olarak değerlendirilir:

// matematik.berk
export işlev topla(a: Sayı, b: Sayı) -> Sayı {
    geri dön a + b
}

export sabit PI = 3.14159

// ana.berk
import matematik

işlev ana() {
    yazdır(matematik.topla(5, 3))
    yazdır(matematik.PI)
}

Örnek: Tam Program

// Fibonacci sayı dizisi hesaplama

import math

// Recursive versiyonu
işlev fib_recursive(n: Sayı) -> Sayı {
    eğer n <= 1 {
        geri dön n
    }
    geri dön fib_recursive(n - 1) + fib_recursive(n - 2)
}

// Iterative versiyonu (daha verimli)
işlev fib_iterative(n: Sayı) -> Sayı {
    eğer n <= 1 {
        geri dön n
    }
    
    değişken a = 0
    değişken b = 1
    
    döngü i 2'den n+1'e kadar {
        değişken temp = a + b
        a = b
        b = temp
    }
    
    geri dön b
}

işlev ana() {
    sabit N = 10
    
    yazdır("İlk ", N, " Fibonacci sayısı:")
    
    döngü i 0'dan N'ye kadar {
        yazdır("fib(", i, ") = ", fib_iterative(i))
    }
}

Stil Rehberi Özeti

Bir Sonraki

• Değişkenler ve Sabitler
• Veri Tipleri
• Operatörler

Değişkenler ve Sabitler

BERK'te değerler saklamak için değişkenler (variables) ve sabitler (constants) kullanılır.

Değişken Tanımlama

Türkçe Syntax

değişken x = 10
değişken isim = "Ahmet"
değişken pi = 3.14159

İngilizce Syntax

var x = 10
var name = "John"
var pi = 3.14159

Tip Belirtme

BERK statik tipli bir dildir. Tip çıkarımı (type inference) desteklenir:

// Tip çıkarımı (önerilen)
değişken sayı = 42          // Sayı tipi
değişken metin = "Hello"    // Yazı tipi
değişken gerçek = 3.14      // Sayı tipi (float)

// Açık tip belirtimi
değişken sayı: Sayı = 42
değişken metin: Yazı = "Hello"
değişken liste: Liste<Sayı> = [1, 2, 3]

Değişken Değiştirme

Değişkenler tanımlandıktan sonra değerleri değiştirilebilir:

değişken sayaç = 0
yazdır(sayaç)  // 0

sayaç = sayaç + 1
yazdır(sayaç)  // 1

sayaç += 5
yazdır(sayaç)  // 6

Sabitler (Constants)

Sabitler bir kez atandıktan sonra değiştirilemez:

sabit PI = 3.14159
sabit MAX_KULLANICI = 100
sabit UYGULAMA_ADI = "BERK App"

// Hata! Sabit değiştirilemez
// PI = 3.14  // Derleme hatası

İngilizce Syntax

const PI = 3.14159
const MAX_USERS = 100

İsimlendirme Kuralları

Değişkenler

• snake_case kullanın (önerilen)
• Türkçe karakterler desteklenir
• Sayı ile başlayamaz
• Anahtar kelime olamaz

// Geçerli değişken isimleri
değişken kullanıcı_adı = "Ayşe"
değişken toplam_fiyat = 99.99
değişken öğrenci_numarası = 12345
değişken değer1 = 10
değişken _private = "gizli"

// Geçersiz değişken isimleri
// değişken 1değer = 10      // Sayı ile başlıyor
// değişken işlev = 5        // Anahtar kelime
// değişken user-name = ""   // Tire kullanılamaz

Sabitler

• SCREAMING_SNAKE_CASE kullanın
• Tümü büyük harf
• Kelimeler alt çizgi ile ayrılır

sabit MAX_DEĞER = 1000
sabit VERSİYON_NUMARASI = "0.8.0"
sabit HATA_MESAJI = "Geçersiz giriş"

Kapsam (Scope)

Global Değişkenler

Fonksiyon dışında tanımlanan değişkenler global'dir:

değişken global_sayaç = 0  // Global

işlev artır() {
    global_sayaç += 1
}

işlev ana() {
    yazdır(global_sayaç)  // 0
    artır()
    yazdır(global_sayaç)  // 1
}

Yerel Değişkenler

Fonksiyon içinde tanımlanan değişkenler yerel'dir:

işlev hesapla() {
    değişken yerel = 10  // Sadece bu fonksiyonda erişilebilir
    yazdır(yerel)
}

işlev ana() {
    hesapla()
    // yazdır(yerel)  // Hata! yerel burada tanımlı değil
}

Blok Kapsamı

Her blok kendi kapsamını oluşturur:

işlev ana() {
    değişken x = 10
    
    eğer x > 5 {
        değişken y = 20  // Bu blokta geçerli
        yazdır(x, y)     // 10, 20
    }
    
    yazdır(x)     // 10
    // yazdır(y)  // Hata! y bu kapsamda yok
}

Shadowing

İç kapsamda aynı isimli değişken tanımlanabilir:

işlev ana() {
    değişken x = 5
    yazdır(x)  // 5
    
    {
        değişken x = 10  // Farklı değişken
        yazdır(x)        // 10
    }
    
    yazdır(x)  // 5 (dış kapsam)
}

Destructuring

Tuple ve listelerden değer çıkarma:

// Tuple destructuring
değişken (x, y) = (10, 20)
yazdır(x)  // 10
yazdır(y)  // 20

// Liste destructuring
değişken [ilk, ikinci, ...geri_kalan] = [1, 2, 3, 4, 5]
yazdır(ilk)         // 1
yazdır(ikinci)      // 2
yazdır(geri_kalan)  // [3, 4, 5]

Çoklu Atama

Birden fazla değişkeni aynı anda tanımlama:

değişken a, b, c = 1, 2, 3
yazdır(a, b, c)  // 1 2 3

// Değer takası (swap)
değişken x = 10
değişken y = 20
x, y = y, x
yazdır(x, y)  // 20 10

Nullable Değişkenler

Değişkenler null olabilir:

değişken değer: Sayı? = null  // Nullable tip

eğer değer != null {
    yazdır("Değer: ", değer)
} değilse {
    yazdır("Değer yok")
}

// Varsayılan değer ile
değişken sonuç = değer ?: 0  // Eğer null ise 0 kullan

Type Aliasing

Tip takma adları:

tip KullanıcıID = Sayı
tip Eposta = Yazı

değişken id: KullanıcıID = 12345
değişken email: Eposta = "user@example.com"

Best Practices

✅ Yapılması Gerekenler

// Anlamlı isimler kullanın
değişken öğrenci_sayısı = 30
değişken toplam_fiyat = 199.99

// Sabitler için büyük harf
sabit MAX_RETRY = 3
sabit API_URL = "https://api.example.com"

// Tip belirtimi gerektiğinde
değişken liste: Liste<Yazı> = []
değişken harita: Harita<Yazı, Sayı> = {}

❌ Kaçınılması Gerekenler

// Çok kısa veya anlamsız isimler
değişken x = 30
değişken tmp = 199.99
değişken a1, a2, a3 = 1, 2, 3

// Tutarsız isimlendirme
değişken UserName = ""    // PascalCase değişkende kullanılmaz
değişken user-name = ""   // Tire kullanılamaz

// Gereksiz tip belirtimi (tip çıkarımı yeterli)
değişken sayı: Sayı = 10  // Gereksiz, "değişken sayı = 10" yeter

Örnek Program

import math

// Global sabitler
sabit YERÇEKIMI = 9.81  // m/s²
sabit PI = 3.14159

işlev dairesel_hareket(yarıçap: Sayı, hız: Sayı) -> Sayı {
    // Merkezcil ivme hesaplama
    değişken ivme = (hız * hız) / yarıçap
    geri dön ivme
}

işlev serbest_düşüş(yükseklik: Sayı) -> Sayı {
    // v = sqrt(2 * g * h)
    değişken hız = math.sqrt(2.0 * YERÇEKIMI * yükseklik)
    geri dön hız
}

işlev ana() {
    // Değişkenler
    değişken yarıçap = 5.0   // metre
    değişken hız = 10.0      // m/s
    
    değişken ivme = dairesel_hareket(yarıçap, hız)
    yazdır("Merkezcil ivme: ", ivme, " m/s²")
    
    // Sabit değer
    sabit YÜKSEKLİK = 50.0  // metre
    değişken düşüş_hızı = serbest_düşüş(YÜKSEKLİK)
    yazdır("Düşüş hızı: ", düşüş_hızı, " m/s")
}

Bir Sonraki

• Veri Tipleri
• Operatörler

Veri Tipleri

BERK statik tipli bir dildir ve çeşitli built-in veri tipleri sunar.

Temel Tipler

Sayı (Number)

Tamsayı ve ondalıklı sayılar için:

değişken tam = 42
değişken ondalık = 3.14
değişken negatif = -100
değişken bilimsel = 1.5e10  // 15000000000

Yazı (String)

Metin değerleri:

değişken isim = "Ahmet"
değişken mesaj = 'Merhaba Dünya!'
değişken çok_satır = """
    Bu
    çok satırlı
    bir metindir
"""

String interpolation:

değişken ad = "Ali"
değişken yaş = 25
yazdır("Benim adım {ad} ve {yaş} yaşındayım")
// Çıktı: Benim adım Ali ve 25 yaşındayım

Boolean (Mantıksal)

Doğru/yanlış değerleri:

değişken doğru_mu = doğru  // true
değişken yanlış_mı = yanlış  // false

// İngilizce
var is_valid = true
var is_empty = false

Null

Değer yokluğu:

değişken değer = null
değişken sonuç: Sayı? = null  // Nullable tip

Koleksiyon Tipleri

Liste (List)

Sıralı elemanlar koleksiyonu:

değişken sayılar = [1, 2, 3, 4, 5]
değişken isimler: Liste<Yazı> = ["Ahmet", "Mehmet", "Ayşe"]
değişken karışık = [1, "iki", 3.0, doğru]  // Mixed types

// Erişim
yazdır(sayılar[0])   // 1
yazdır(isimler[2])   // Ayşe

// Değiştirme
sayılar[0] = 10

// Uzunluk
yazdır(sayılar.uzunluk)  // 5

Liste metodları:

değişken liste = [1, 2, 3]

liste.ekle(4)           // [1, 2, 3, 4]
liste.çıkar(1)          // [1, 3, 4]
liste.içerir(3)         // doğru
liste.temizle()         // []

Demet (Tuple)

Sabit boyutlu, farklı tipli elemanlar:

değişken konum = (41.0082, 28.9784)  // (lat, lon)
değişken kişi = ("Ahmet", 30, "İstanbul")

// Destructuring
değişken (lat, lon) = konum
değişken (ad, yaş, şehir) = kişi

// İndeks erişimi
yazdır(konum.0)  // 41.0082
yazdır(kişi.1)   // 30

Harita (Map/Dictionary)

Anahtar-değer çiftleri:

değişken sözlük = {
    "ad": "Ahmet",
    "yaş": 30,
    "şehir": "İstanbul"
}

// Erişim
yazdır(sözlük["ad"])  // Ahmet

// Ekleme/Güncelleme
sözlük["meslek"] = "Mühendis"
sözlük["yaş"] = 31

// Kontrol
eğer sözlük.içerir("ad") {
    yazdır("Ad bulundu")
}

// Tip belirtimi
değişken notlar: Harita<Yazı, Sayı> = {
    "Matematik": 85,
    "Fizik": 90,
    "Kimya": 78
}

Küme (Set)

Benzersiz elemanlar koleksiyonu:

değişken kume = {1, 2, 3, 3, 2, 1}  // {1, 2, 3}

kume.ekle(4)      // {1, 2, 3, 4}
kume.çıkar(2)     // {1, 3, 4}
kume.içerir(3)    // doğru

// Set işlemleri
değişken a = {1, 2, 3}
değişken b = {2, 3, 4}

değişken birleşim = a | b     // {1, 2, 3, 4}
değişken kesişim = a & b      // {2, 3}
değişken fark = a - b         // {1}

Struct Tipleri

Özel veri yapıları tanımlama:

tür Kişi = struct {
    ad: Yazı,
    yaş: Sayı,
    email: Yazı
}

// Instance oluşturma
değişken kişi = Kişi {
    ad: "Ahmet",
    yaş: 30,
    email: "ahmet@example.com"
}

// Alan erişimi
yazdır(kişi.ad)      // Ahmet
yazdır(kişi.yaş)     // 30

// Güncelleme
kişi.yaş = 31

Enum Tipleri

Sabit değerler kümesi:

tür Renk = enum {
    Kırmızı,
    Yeşil,
    Mavi
}

değişken favori = Renk.Kırmızı

eş favori {
    Renk.Kırmızı => yazdır("Kırmızı seçildi"),
    Renk.Yeşil => yazdır("Yeşil seçildi"),
    Renk.Mavi => yazdır("Mavi seçildi")
}

Enum değerlerle:

tür HttpDurum = enum {
    Tamam = 200,
    Bulunamadı = 404,
    Sunucu Hatası = 500
}

değişken durum = HttpDurum.Tamam
yazdır(durum.değer)  // 200

Sonuç Tipi (Result)

Hata yönetimi için:

tür Sonuç<T, E> = enum {
    Tamam(T),
    Hata(E)
}

işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
    eğer b == 0 {
        hata dön "Sıfıra bölme!"
    }
    tamam dön a / b
}

değişken sonuç = böl(10, 2)
eş sonuç {
    Tamam(değer) => yazdır("Sonuç: ", değer),
    Hata(mesaj) => yazdır("HATA: ", mesaj)
}

Seçenek Tipi (Option)

Nullable alternatifi:

tür Seçenek<T> = enum {
    Bazı(T),
    Hiç
}

işlev bul(liste: Liste<Sayı>, hedef: Sayı) -> Seçenek<Sayı> {
    döngü i 0'dan liste.uzunluk'a kadar {
        eğer liste[i] == hedef {
            geri dön Bazı(i)
        }
    }
    geri dön Hiç
}

değişken indeks = bul([1, 2, 3, 4], 3)
eş indeks {
    Bazı(i) => yazdır("Bulundu: ", i),
    Hiç => yazdır("Bulunamadı")
}

Tip Dönüşümleri

Açık Dönüşüm (Casting)

değişken x = 10
değişken y = x as Ondalık  // 10.0

değişken metin = "42"
değişken sayı = metin.parse<Sayı>()  // 42

Tip Kontrol

değişken değer: Any = "Hello"

eğer değer is Yazı {
    yazdır("Bu bir string")
}

eğer değer is Sayı {
    yazdır("Bu bir sayı")
}

Tip Takma Adları (Type Alias)

tür KullanıcıID = Sayı
tür Email = Yazı
tür Koordinat = (Sayı, Sayı)

değişken id: KullanıcıID = 12345
değişken email: Email = "user@example.com"
değişken konum: Koordinat = (41.0, 29.0)

Boyutlar ve Sınırlar

sabit SAYI_MIN = -9223372036854775808  // i64 min
sabit SAYI_MAX = 9223372036854775807   // i64 max

sabit ONDALIK_MIN = -1.7976931348623157e+308  // f64 min
sabit ONDALIK_MAX = 1.7976931348623157e+308   // f64 max

sabit YAZI_MAX_UZUNLUK = 2147483647  // ~2GB

Tip Çıkarımı

BERK güçlü tip çıkarımı yapar:

// Tip otomatik belirlenir
değişken sayı = 42            // Sayı
değişken pi = 3.14            // Ondalık
değişken isim = "Ahmet"       // Yazı
değişken doğru_mu = doğru     // Boolean
değişken liste = [1, 2, 3]    // Liste<Sayı>

// Karmaşık çıkarımlar
değişken harita = {           // Harita<Yazı, Sayı>
    "a": 1,
    "b": 2
}

değişken fonksiyon = (x) => x * 2  // (Sayı) -> Sayı

Best Practices

✅ Yapılması Gerekenler

// Açık tip belirtimi karmaşık durumlarda
değişken kullanıcılar: Liste<Kullanıcı> = []

// Immutable veri için const kullan
sabit API_ANAHTARI = "gizli_anahtar"

// Result tipi hata yönetimi için
işlev dosya_oku(yol: Yazı) -> Sonuç<Yazı, Hata> { ... }

❌ Kaçınılması Gerekenler

// Gereksiz tip belirtimi
değişken x: Sayı = 10  // "değişken x = 10" yeterli

// Any tipini fazla kullanmak
değişken karışık: Any = ...  // Mümkünse spesifik tip kullan

// Null yerine Option kullan
değişken değer = null  // Option<T> tercih et

Örnek: Tüm Tipler

işlev ana() {
    // Temel tipler
    değişken sayı: Sayı = 42
    değişken ondalık: Ondalık = 3.14
    değişken metin: Yazı = "Hello"
    değişken bool: Boolean = doğru
    
    // Koleksiyonlar
    değişken liste: Liste<Sayı> = [1, 2, 3]
    değişken demet: (Sayı, Yazı) = (1, "bir")
    değişken harita: Harita<Yazı, Sayı> = {"a": 1}
    değişken küme: Küme<Sayı> = {1, 2, 3}
    
    // Özel tipler
    tür Nokta = struct { x: Sayı, y: Sayı }
    değişken p = Nokta { x: 10, y: 20 }
    
    // Sonuç tipi
    değişken sonuç: Sonuç<Sayı, Yazı> = Tamam(42)
}

Bir Sonraki

• Operatörler
• Yorumlar

Operatörler

BERK'te çeşitli operatörler matematiksel işlemler, karşılaştırmalar ve mantıksal işlemler için kullanılır.

Aritmetik Operatörler

Temel İşlemler

değişken a = 10
değişken b = 3

yazdır(a + b)   // 13 - Toplama
yazdır(a - b)   // 7  - Çıkarma
yazdır(a * b)   // 30 - Çarpma
yazdır(a / b)   // 3  - Bölme (tamsayı)
yazdır(a % b)   // 1  - Mod (kalan)
yazdır(a ** b)  // 1000 - Üs alma

Ondalık Bölme

değişken x = 10.0
değişken y = 3.0

yazdır(x / y)   // 3.333333 - Ondalık bölme

Unary Operatörler

değişken n = 5

yazdır(+n)  // 5  - Pozitif işareti
yazdır(-n)  // -5 - Negatif işareti
yazdır(++n) // 6  - Ön artırma
yazdır(n++) // 6  - Son artırma (7 olur)
yazdır(--n) // 6  - Ön azaltma
yazdır(n--) // 6  - Son azaltma (5 olur)

Karşılaştırma Operatörleri

değişken a = 10
değişken b = 5

yazdır(a == b)  // yanlış - Eşit mi
yazdır(a != b)  // doğru  - Eşit değil mi
yazdır(a > b)   // doğru  - Büyük mü
yazdır(a < b)   // yanlış - Küçük mü
yazdır(a >= b)  // doğru  - Büyük eşit mi
yazdır(a <= b)  // yanlış - Küçük eşit mi

Mantıksal Operatörler

değişken x = doğru
değişken y = yanlış

yazdır(x && y)  // yanlış - VE (AND)
yazdır(x || y)  // doğru  - VEYA (OR)
yazdır(!x)      // yanlış - DEĞİL (NOT)

Short-Circuit Evaluation

// İkinci ifade değerlendirilmez
eğer (x || çağır_fonksiyon()) {
    // x doğru ise çağır_fonksiyon() çalıştırılmaz
}

// İkinci ifade değerlendirilir
eğer (x && çağır_fonksiyon()) {
    // x yanlış ise çağır_fonksiyon() çalıştırılmaz
}

Atama Operatörleri

Basit Atama

değişken x = 10
x = 20  // Yeni değer atama

Bileşik Atama

değişken n = 10

n += 5   // n = n + 5  (15)
n -= 3   // n = n - 3  (12)
n *= 2   // n = n * 2  (24)
n /= 4   // n = n / 4  (6)
n %= 5   // n = n % 5  (1)
n **= 3  // n = n ** 3 (1)

Çoklu Atama

değişken a, b, c = 1, 2, 3
yazdır(a, b, c)  // 1 2 3

// Değer takası (swap)
a, b = b, a
yazdır(a, b)  // 2 1

Bitwise Operatörler

değişken a = 0b1010  // 10
değişken b = 0b1100  // 12

yazdır(a & b)   // 0b1000 (8)  - AND
yazdır(a | b)   // 0b1110 (14) - OR
yazdır(a ^ b)   // 0b0110 (6)  - XOR
yazdır(~a)      // 0b0101 (-11) - NOT
yazdır(a << 1)  // 0b10100 (20) - Sol kaydırma
yazdır(a >> 1)  // 0b0101 (5)   - Sağ kaydırma

String Operatörleri

Birleştirme

değişken ad = "Ahmet"
değişken soyad = "Yılmaz"

değişken tam_ad = ad + " " + soyad
yazdır(tam_ad)  // Ahmet Yılmaz

// Bileşik atama
değişken mesaj = "Merhaba "
mesaj += "Dünya"
yazdır(mesaj)  // Merhaba Dünya

Tekrarlama

değişken yıldız = "*" * 10
yazdır(yıldız)  // **********

Karşılaştırma

yazdır("abc" == "abc")   // doğru
yazdır("abc" < "abd")    // doğru (leksikografik)
yazdır("a" + "b" == "ab") // doğru

Range Operatörü

// Inclusive range (son dahil)
döngü i 1'den 5'e kadar {
    yazdır(i)  // 1, 2, 3, 4, 5
}

// Exclusive range (son hariç)
döngü i 1'den 5'e {
    yazdır(i)  // 1, 2, 3, 4
}

// Liste oluşturma
değişken sayılar = [1..10]  // [1, 2, 3, ..., 10]
değişken harfler = ['a'..'z']

Elvis Operatörü (Null Coalescing)

değişken değer: Sayı? = null

// Eğer null ise varsayılan değer kullan
değişken sonuç = değer ?: 0
yazdır(sonuç)  // 0

değer = 42
sonuç = değer ?: 0
yazdır(sonuç)  // 42

Safe Navigation Operatörü

değişken kullanıcı: Kullanıcı? = null

// Null kontrolü olmadan güvenli erişim
değişken email = kullanıcı?.email
// Eğer kullanıcı null ise email de null olur

// Zincirleme
değişken şehir = kullanıcı?.adres?.şehir?.ad

Pipeline Operatörü

// Fonksiyon zincirleme
değişken sonuç = [1, 2, 3, 4, 5]
    |> filtrele(x => x % 2 == 0)
    |> eşle(x => x * 2)
    |> azalt((a, b) => a + b)

yazdır(sonuç)  // 12 (2*2 + 4*2)

Spread Operatörü

// Liste spread
değişken liste1 = [1, 2, 3]
değişken liste2 = [4, 5, 6]
değişken birleşik = [...liste1, ...liste2]
yazdır(birleşik)  // [1, 2, 3, 4, 5, 6]

// Fonksiyon argümanı
işlev topla(a, b, c) -> Sayı {
    geri dön a + b + c
}

değişken args = [1, 2, 3]
yazdır(topla(...args))  // 6

Ternary Operatörü

değişken yaş = 18
değişken durum = yaş >= 18 ? "Yetişkin" : "Çocuk"
yazdır(durum)  // Yetişkin

// İç içe ternary
değişken not = 85
değişken harf = not >= 90 ? "A" :
                not >= 80 ? "B" :
                not >= 70 ? "C" : "F"
yazdır(harf)  // B

Type Check Operatörü

değişken değer: Any = "Hello"

eğer değer is Yazı {
    yazdır("Bu bir string")
}

eğer değer !is Sayı {
    yazdır("Bu bir sayı değil")
}

// Casting ile
değişken metin = değer as Yazı

In Operatörü

// Liste kontrol
değişken sayılar = [1, 2, 3, 4, 5]
eğer 3 in sayılar {
    yazdır("3 listede var")
}

// String kontrol
değişken metin = "Merhaba Dünya"
eğer "Dünya" in metin {
    yazdır("'Dünya' bulundu")
}

// Range kontrol
eğer 5 in 1..10 {
    yazdır("5 aralıkta")
}

// Map kontrol
değişken sözlük = {"ad": "Ahmet", "yaş": 30}
eğer "ad" in sözlük {
    yazdır("'ad' anahtarı var")
}

Operatör Önceliği

Yüksekten düşüğe:

Parantezle Öncelik Değiştirme

değişken a = 2 + 3 * 4      // 14 (çarpma önce)
değişken b = (2 + 3) * 4    // 20 (toplama önce)

değişken c = 10 / 2 + 3     // 8
değişken d = 10 / (2 + 3)   // 2

Özel Operatörler

Assert Operatörü

değişken x = 10
assert x > 0, "x pozitif olmalı"

// Eğer koşul yanlış ise program durur

Match Operatörü

değişken sayı = 2

değişken sonuç = sayı eş {
    1 => "bir",
    2 => "iki",
    3 => "üç",
    _ => "diğer"
}

yazdır(sonuç)  // iki

Best Practices

✅ Yapılması Gerekenler

// Karmaşık ifadelerde parantez kullan
değişken sonuç = (a + b) * (c - d)

// Short-circuit evaluation'dan faydalanın
eğer kullanıcı != null && kullanıcı.aktif {
    // ...
}

// Null-safe operatörler kullan
değişken email = kullanıcı?.email ?: "Bilinmiyor"

// Operatör etrafında boşluk
değişken toplam = a + b  // İyi
değişken toplam = a+b    // Okunabilir değil

❌ Kaçınılması Gerekenler

// Çok uzun ternary zincirleri
değişken x = a ? b ? c ? d : e : f : g  // Okunması zor

// Gereksiz karmaşık bitwise işlemler
değişken y = (a & b) | (~c ^ d)  // Ne yaptığı belli değil

// Yan etki yaratan operatörler
değişken z = x++ + ++x + x++  // Kafa karıştırıcı

Örnek: Çeşitli Operatörler

işlev ana() {
    // Aritmetik
    değişken toplam = 10 + 20
    değişken fark = 100 - 50
    değişken çarpım = 5 * 6
    değişken bölüm = 20 / 4
    
    // Karşılaştırma
    eğer toplam > fark {
        yazdır("Toplam daha büyük")
    }
    
    // Mantıksal
    değişken a = doğru
    değişken b = yanlış
    eğer a && !b {
        yazdır("Koşul sağlandı")
    }
    
    // String
    değişken mesaj = "Merhaba" + " " + "Dünya"
    
    // Null-safe
    değişken değer: Sayı? = null
    değişken sonuç = değer ?: 0
    
    yazdır("Tüm işlemler tamamlandı")
}

Bir Sonraki

• Kontrol Yapıları
• Fonksiyonlar

Yorumlar

BERK'te kod içine açıklama eklemek için yorumlar kullanılır.

Tek Satırlık Yorumlar

Çift slash (//) ile başlar:

// Bu bir yorumdur
değişken x = 10  // Satır sonunda yorum

işlev hesapla() {
    // Fonksiyon içinde yorum
    geri dön 42
}

Çok Satırlı Yorumlar

/* ile başlar, */ ile biter:

/*
   Bu çok satırlı
   bir yorumdur.
   Birden fazla satır içerebilir.
*/

değişken sonuç = /* inline yorum */ 42

Dokümantasyon Yorumları

Üçlü slash (///) fonksiyon ve modül dokümantasyonu için kullanılır:

/// İki sayının toplamını hesaplar.
/// 
/// Parametreler:
/// - a: İlk sayı
/// - b: İkinci sayı
/// 
/// Dönüş: İki sayının toplamı
işlev topla(a: Sayı, b: Sayı) -> Sayı {
    geri dön a + b
}

Best Practices

✅ İyi Yorumlar

// Kullanıcı kimliğini veritabanından çek
değişken kullanıcı = db.getir(id)

// HACK: Geçici çözüm, v0.9'da düzeltilecek
değişken temp_fix = workaround()

// TODO: Performans optimizasyonu gerekli
işlev yavaş_fonksiyon() { ... }

// FIXME: Edge case'lerde hata veriyor
işlev hatalı_fonksiyon() { ... }

❌ Kötü Yorumlar

// x'i 1 artır
x += 1  // Gereksiz, kod zaten açık

// Bu fonksiyon bir şey yapar
işlev bir_şey_yap() { ... }  // Belirsiz

// Değişken tanımla
değişken y = 10  // Anlamsız yorum

Annotation'lar

Özel yorumlar kodun davranışını etkileyebilir:

// @deprecated: Artık kullanılmıyor, yerine yeni_fonksiyon() kullanın
işlev eski_fonksiyon() { ... }

// @performance: Kritik yol, optimizasyon önemli
işlev sık_çağrılan() { ... }

// @unsafe: Manuel bellek yönetimi
işlev düşük_seviye() { ... }

Kontrol Yapıları

BERK'te program akışını kontrol etmek için çeşitli yapılar sunulur.

İçindekiler

If-Else Koşulları

Koşullu ifadeler ve dallanma:

eğer x > 0 {
    yazdır("Pozitif")
} değilse {
    yazdır("Negatif veya sıfır")
}

Döngüler

Tekrarlı işlemler için döngü yapıları:

• döngü (for)
• iken (while)
• yap-iken (do-while)

döngü i 0'dan 5'e kadar {
    yazdır(i)
}

Pattern Matching

Gelişmiş eşleştirme ve yıkımlandırma:

eş deđfer {
    Tamam(x) => yazdır("Başarılı: ", x),
    Hata(e) => yazdır("Hata: ", e)
}

Hızlı Karşılaştırma

Bir Sonraki

Detaylı bilgi için alt sayfaları inceleyin.

If-Else Koşulları

Koşullu ifadeler program akışını kontrol eder.

Temel If

eğer x > 0 {
    yazdır("Pozitif sayı")
}

İngilizce syntax:

if x > 0 {
    print("Positive number")
}

If-Else

eğer yaş >= 18 {
    yazdır("Yetişkin")
} değilse {
    yazdır("Çocuk")
}

Else If

eğer not >= 90 {
    yazdır("Pekiyi")
} değilse eğer not >= 80 {
    yazdır("İyi")
} değilse eğer not >= 70 {
    yazdır("Orta")
} değilse {
    yazdır("Zayıf")
}

İç İçe If

eğer kullanıcı != null {
    eğer kullanıcı.aktif {
        eğer kullanıcı.doğrulanmış {
            yazdır("Giriş başarılı")
        }
    }
}

Ternary Operatörü

değişken durum = yaş >= 18 ? "Yetişkin" : "Çocuk"

If Expression

BERK'te if bir ifade olarak kullanılabilir:

değişken maksimum = eğer a > b { a } değilse { b }

değişken mesaj = eğer hata {
    "Hata oluştu"
} değilse {
    "Başarılı"
}

Guard Clauses

Erken dönüş deseni:

işlev işle(değer: Sayı?) -> Sonuç<Sayı, Yazı> {
    eğer değer == null {
        hata dön "Değer null olamaz"
    }
    
    eğer değer < 0 {
        hata dön "Değer negatif olamaz"
    }
    
    tamam dön değer * 2
}

Mantıksal Operatörlerle

eğer yaş >= 18 && ehliyet_var {
    yazdır("Araç kullanabilir")
}

eğer admin || moderator {
    yazdır("Yetki var")
}

eğer !boş_mu {
    yazdır("Veri var")
}

Short-Circuit Evaluation

// İkinci ifade değerlendirilmez
eğer kullanıcı == null || kullanıcı.sil() {
    // kullanıcı null ise sil() çağrılmaz
}

Best Practices

✅ Yapılması Gerekenler

// Anlamlı değişkenler
eğer kullanıcı_doğrulandı && oturum_geçerli {
    izin_ver()
}

// Guard clauses kullanın
eğer !geçerli_mi {
    geri dön
}

// Pozitif koşullar tercih edin
eğer aktif {
    işle()
}

❌ Kaçınılması Gerekenler

// Çok uzun if-else zincirleri
eğer x == 1 {
    ...
} değilse eğer x == 2 {
    ...
} // 20 tane else if
// Bunun yerine match kullanın!

// Gereksiz iç içe if
eğer a {
    eğer b {
        eğer c {
            // 5 seviye
        }
    }
}
// && operatörü kullanın

Döngüler

Tekrarlı işlemler için döngü yapıları.

For Döngüsü (Range)

// 0'dan 4'e kadar (5 hariç)
döngü i 0'dan 5'e {
    yazdır(i)  // 0, 1, 2, 3, 4
}

// 0'dan 5'e kadar (5 dahil)
döngü i 0'dan 6'ya kadar {
    yazdır(i)  // 0, 1, 2, 3, 4, 5
}

// Tersden sayma
döngü i 10'dan 0'a {
    yazdır(i)  // 10, 9, 8, ..., 1
}

// Adım boyutu
döngü i 0'dan 10'a adım 2 {
    yazdır(i)  // 0, 2, 4, 6, 8
}

İngilizce syntax:

for i from 0 to 5 {
    print(i)
}

for i from 0 to 5 inclusive {
    print(i)
}

For-Each Döngüsü

değişken sayılar = [1, 2, 3, 4, 5]

döngü sayı sayılarda {
    yazdır(sayı)
}

// İndeks ile
döngü (indeks, değer) sayılarda {
    yazdır(indeks, ": ", değer)
}

İngilizce:

for num in numbers {
    print(num)
}

for (index, value) in numbers {
    print(index, ": ", value)
}

While Döngüsü

değişken sayaç = 0

iken sayaç < 5 {
    yazdır(sayaç)
    sayaç += 1
}

İngilizce:

var counter = 0

while counter < 5 {
    print(counter)
    counter += 1
}

Do-While Döngüsü

En az bir kez çalışır:

değişken x = 0

yap {
    yazdır(x)
    x += 1
} iken x < 5

Sonsuz Döngü

döngü {
    // Sonsuz döngü
    eğer koşul {
        kır  // Çıkış
    }
}

Break ve Continue

Break (Kır)

Döngüden çık:

döngü i 0'dan 10'a {
    eğer i == 5 {
        kır  // Döngü durur
    }
    yazdır(i)  // 0, 1, 2, 3, 4
}

Continue (Devam)

Sonraki iterasyona geç:

döngü i 0'dan 10'a {
    eğer i % 2 == 0 {
        devam  // Çift sayıları atla
    }
    yazdır(i)  // 1, 3, 5, 7, 9 (tek sayılar)
}

İç İçe Döngüler

döngü i 1'den 4'e {
    döngü j 1'den 4'e {
        yazdır(i * j, " ", sonlandırma: "")
    }
    yazdır()  // Yeni satır
}
// Çıktı:
// 1 2 3
// 2 4 6
// 3 6 9

Etiketli break:

dış: döngü i 0'dan 5'e {
    iç: döngü j 0'dan 5'e {
        eğer i * j > 10 {
            kır dış  // Dış döngüden çık
        }
        yazdır(i, "*", j, "=", i*j)
    }
}

Döngü ile Koleksiyonlar

Liste Üzerinde

değişken meyveler = ["elma", "armut", "kiraz"]

döngü meyve meyvelerde {
    yazdır(meyve)
}

// Filtreleme
döngü meyve meyvelerde {
    eğer meyve.uzunluk > 4 {
        yazdır(meyve)
    }
}

Map Üzerinde

değişken yaşlar = {
    "Ahmet": 25,
    "Mehmet": 30,
    "Ayşe": 28
}

döngü (isim, yaş) yaşlarda {
    yazdır(isim, ": ", yaş)
}

Range ile

// 1'den 10'a (10 dahil)
döngü x [1..10]'da {
    yazdır(x)
}

// Filtreli range
döngü x [1..20]'de {
    eğer x % 3 == 0 {
        yazdır(x)  // 3'e bölünenler
    }
}

Iterator Metodları

değişken sayılar = [1, 2, 3, 4, 5]

// Map
değişken kareler = sayılar.eşle(x => x * x)

// Filter
değişken çiftler = sayılar.filtrele(x => x % 2 == 0)

// Reduce
değişken toplam = sayılar.azalt((a, b) => a + b)

// ForEach
sayılar.herbiri(x => yazdır(x))

Best Practices

✅ Yapılması Gerekenler

// Anlamlı değişken isimleri
döngü öğrenci öğrencilerde {
    işle(öğrenci)
}

// For-each tercih edin
değişken liste = [1, 2, 3]
döngü eleman listede {  // İyi
    yazdır(eleman)
}

// Iterator metodları kullanın
değişken sonuç = sayılar
    .filtrele(x => x > 0)
    .eşle(x => x * 2)
    .azalt((a, b) => a + b)

❌ Kaçınılması Gerekenler

// Manuel indeks yönetimi
döngü i 0'dan liste.uzunluk'a {
    yazdır(liste[i])  // Kötü
}
// Bunun yerine:
döngü eleman listede {
    yazdır(eleman)  // İyi
}

// Sonsuz döngü tuzakları
iken doğru {  // Tehlikeli
    // Çıkış koşulu olmadan
}

// Gereksiz iç içe döngüler
// O(n²) veya daha kötü karmaşıklık

Örnekler

Fibonacci

işlev fibonacci(n: Sayı) -> Liste<Sayı> {
    değişken sonuç = [0, 1]
    
    döngü i 2'den n'ye {
        değişken sonraki = sonuç[i-1] + sonuç[i-2]
        sonuç.ekle(sonraki)
    }
    
    geri dön sonuç
}

Asal Sayılar

işlev asal_mi(n: Sayı) -> Boolean {
    eğer n < 2 {
        geri dön yanlış
    }
    
    döngü i 2'den n'ye {
        eğer i * i > n {
            kır
        }
        eğer n % i == 0 {
            geri dön yanlış
        }
    }
    
    geri dön doğru
}

Pattern Matching

Gelişmiş eşleştirme ve değer yıkımlandırma.

Temel Match

değişken sayı = 2

eş sayı {
    1 => yazdır("bir"),
    2 => yazdır("iki"),
    3 => yazdır("üç"),
    _ => yazdır("diğer")
}

İngilizce:

match number {
    1 => print("one"),
    2 => print("two"),
    _ => print("other")
}

Match Expression

Bir değer döndürebilir:

değişken mesaj = eş sayı {
    1 => "bir",
    2 => "iki",
    3 => "üç",
    _ => "bilinmeyen"
}

Result Matching

işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
    eğer b == 0 {
        hata dön "Sıfıra bölme"
    }
    tamam dön a / b
}

değişken sonuç = böl(10, 2)

eş sonuç {
    Tamam(değer) => yazdır("Sonuç: ", değer),
    Hata(mesaj) => yazdır("HATA: ", mesaj)
}

Option Matching

değişken değer: Seçenek<Sayı> = Bazı(42)

eş değer {
    Bazı(x) => yazdır("Değer: ", x),
    Hiç => yazdır("Değer yok")
}

Tuple Destructuring

değişken nokta = (3, 4)

eş nokta {
    (0, 0) => yazdır("Orijin"),
    (x, 0) => yazdır("X ekseni: ", x),
    (0, y) => yazdır("Y ekseni: ", y),
    (x, y) => yazdır("Nokta: (", x, ", ", y, ")")
}

List Patterns

değişken liste = [1, 2, 3]

eş liste {
    [] => yazdır("Boş liste"),
    [x] => yazdır("Tek eleman: ", x),
    [x, y] => yazdır("İki eleman: ", x, ", ", y),
    [ilk, ...geri_kalan] => {
        yazdır("İlk: ", ilk)
        yazdır("Geri kalan: ", geri_kalan)
    }
}

Struct Patterns

tür Kişi = struct {
    ad: Yazı,
    yaş: Sayı
}

değişken kişi = Kişi { ad: "Ahmet", yaş: 30 }

eş kişi {
    Kişi { ad: "Ahmet", yaş } => {
        yazdır("Ahmet, ", yaş, " yaşında")
    },
    Kişi { ad, yaş: 18..25 } => {
        yazdır(ad, " genç")
    },
    _ => yazdır("Diğer")
}

Range Patterns

değişken yaş = 25

eş yaş {
    0..12 => yazdır("Çocuk"),
    13..17 => yazdır("Genç"),
    18..64 => yazdır("Yetişkin"),
    65.. => yazdır("Yaşlı")
}

Guards (Koşullar)

değişken sayı = 15

eş sayı {
    x if x < 0 => yazdır("Negatif"),
    x if x % 2 == 0 => yazdır("Çift"),
    x if x % 2 == 1 => yazdır("Tek"),
    _ => yazdır("Bilinmeyen")
}

Multiple Patterns

eş karakter {
    'a' | 'e' | 'ı' | 'i' | 'o' | 'ö' | 'u' | 'ü' => {
        yazdır("Sesli harf")
    },
    _ => yazdır("Ünssüz harf")
}

Nested Patterns

tür Mesaj = enum {
    Metin(Yazı),
    Sayı(Sayı),
    Çoklu(Liste<Mesaj>)
}

değişken mesaj = Çoklu([Metin("hello"), Sayı(42)])

eş mesaj {
    Metin(s) => yazdır("Metin: ", s),
    Sayı(n) => yazdır("Sayı: ", n),
    Çoklu([Metin(s), Sayı(n)]) => {
        yazdır("Metin ve sayı: ", s, ", ", n)
    },
    _ => yazdır("Diğer")
}

Wildcard Patterns

// Tam wildcard
eş değer {
    _ => yazdır("Herhangi bir şey")
}

// Kısmi wildcard
eş tuple {
    (_, 0) => yazdır("Y sıfır"),
    (0, _) => yazdır("X sıfır"),
    (_, _) => yazdır("Diğer")
}

Best Practices

✅ Yapılması Gerekenler

// Exhaustive matching (tüm durumlar)
eş sonuç {
    Tamam(x) => işle(x),
    Hata(e) => hata_işle(e)
    // _ gerekli değil, tüm durumlar kapsıyor
}

// Anlamlı değişken isimleri
eş kullanıcı {
    Kişi { ad: kullanıcı_adı, yaş: kullanıcı_yaşı } => {
        // ...
    }
}

❌ Kaçınılması Gerekenler

// Çok karmaşık iç içe pattern
eş değer {
    A(B(C(D(x)))) => ...  // Okunabilir değil
}

// Gereksiz wildcard
eş x {
    _ => ...  // Tüm durumları yok sayıyor
}

Örnekler

JSON Parser

tür Json = enum {
    Null,
    Bool(Boolean),
    Number(Sayı),
    String(Yazı),
    Array(Liste<Json>),
    Object(Harita<Yazı, Json>)
}

işlev stringify(json: Json) -> Yazı {
    eş json {
        Null => "null",
        Bool(b) => b ? "true" : "false",
        Number(n) => n.to_string(),
        String(s) => "\""+s+"\"",
        Array(arr) => "[" + arr.map(stringify).join(",") + "]",
        Object(obj) => "{...}"
    }
}

Fonksiyonlar

Fonksiyonlar tekrar kullanılabilir kod bloklarıdır.

Temel Syntax

işlev topla(a: Sayı, b: Sayı) -> Sayı {
    geri dön a + b
}

İçerikler

• Fonksiyon Tanımlama
• Parametreler ve Dönüş Değerleri
• Yerel ve Global Değişkenler

Fonksiyon Tanımlama

Basit Fonksiyon

işlev selamla() {
    yazdır("Merhaba!")
}

selamla()  // Çağırma

Parametreli Fonksiyon

işlev selamla(isim: Yazı) {
    yazdır("Merhaba, ", isim)
}

selamla("Ahmet")

Dönüş Değerli

işlev topla(a: Sayı, b: Sayı) -> Sayı {
    geri dön a + b
}

değişken sonuç = topla(5, 3)

Lambda Fonksiyonlar

değişken çarp = (x, y) => x * y
yazdır(çarp(3, 4))  // 12

Recursive

işlev faktoriyel(n: Sayı) -> Sayı {
    eğer n <= 1 {
        geri dön 1
    }
    geri dön n * faktoriyel(n - 1)
}

Parametreler ve Dönüş Değerleri

Tek Parametre

işlev kare(x: Sayı) -> Sayı {
    geri dön x * x
}

Çoklu Parametre

işlev hesapla(a: Sayı, b: Sayı, c: Sayı) -> Sayı {
    geri dön a + b * c
}

Varsayılan Değerler

işlev selamla(isim: Yazı = "Misafir") {
    yazdır("Merhaba, ", isim)
}

selamla()          // Merhaba, Misafir
selamla("Ahmet")   // Merhaba, Ahmet

Çoklu Dönüş (Tuple)

işlev böl(a: Sayı, b: Sayı) -> (Sayı, Sayı) {
    değişken bölüm = a / b
    değişken kalan = a % b
    geri dön (bölüm, kalan)
}

değişken (q, r) = böl(10, 3)

Variadic Parametreler

işlev topla(...sayılar: Sayı[]) -> Sayı {
    değişken sonuç = 0
    döngü n sayılarda {
        sonuç += n
    }
    geri dön sonuç
}

yazdır(topla(1, 2, 3, 4))  // 10

Named Parameters

işlev oluştur(isim: Yazı, yaş: Sayı, şehir: Yazı) {
    yazdır(isim, yaş, şehir)
}

oluştur(isim: "Ali", şehir: "İstanbul", yaş: 25)

Yerel ve Global Değişkenler

Global Değişkenler

değişken global_sayaç = 0  // Tüm fonksiyonlardan erişilebilir

işlev artır() {
    global_sayaç += 1
}

Yerel Değişkenler

işlev hesapla() {
    değişken yerel = 10  // Sadece bu fonksiyonda
    geri dön yerel * 2
}

// yazdır(yerel)  // HATA! Erişilemez

Shadowing

değişken x = 5

işlev test() {
    değişken x = 10  // Farklı x
    yazdır(x)        // 10
}

test()
yazdır(x)  // 5

Closure

işlev yap_sayaç() -> İşlev {
    değişken say = 0
    
    geri dön () => {
        say += 1
        geri dön say
    }
}

değişken sayaç = yap_sayaç()
yazdır(sayaç())  // 1
yazdır(sayaç())  // 2

Best Practice

• Global değişkenlerden kaçının
• Sabitler için global kullanın
• Parametre ile veri aktarımı tercih edin

Veri Yapıları

BERK'te yerleşik veri yapıları:

Listeler

Dinamik diziler:

değişken sayılar = [1, 2, 3, 4, 5]

Demetler (Tuples)

Sabit boyutlu, çoklu tip:

değişken kişi = ("Ahmet", 30, "İstanbul")

Struct Yapıları

Özel veri tipleri:

tür Kişi = struct {
    ad: Yazı,
    yaş: Sayı
}

Diğer Yapılar

• Harita (Map): Anahtar-değer çiftleri
• Küme (Set): Benzersiz elemanlar
• Queue/Stack: Kuyruk ve yığın yapıları

Listeler

Dinamik boyutlu diziler.

Oluşturma

değişken boş = []
değişken sayılar = [1, 2, 3, 4, 5]
değişken isimler: Liste<Yazı> = ["Ali", "Ayşe"]

Erişim

yazdır(sayılar[0])     // 1
yazdır(sayılar[-1])    // 5 (sondan)
sayılar[0] = 10        // Değiştirme

Metodlar

değişken liste = [1, 2, 3]

liste.ekle(4)           // [1, 2, 3, 4]
liste.çıkar(1)         // [1, 3, 4]
liste.uzunluk           // 3
liste.içerir(3)         // doğru
liste.temizle()         // []

Slicing

değişken liste = [0, 1, 2, 3, 4, 5]

yazdır(liste[1..3])    // [1, 2]
yazdır(liste[..3])     // [0, 1, 2]
yazdır(liste[3..])     // [3, 4, 5]

Iterator Metodları

değişken sayılar = [1, 2, 3, 4, 5]

// Map
değişken kareler = sayılar.eşle(x => x * x)

// Filter
değişken çiftler = sayılar.filtrele(x => x % 2 == 0)

// Reduce
değişken toplam = sayılar.azalt((a, b) => a + b)

// Sort
liste.sırala()         // Artan sıra
liste.sırala_ters()    // Azalan sıra

Comprehension

değişken kareler = [x * x for x in 1..10]
değişken çiftler = [x for x in 1..20 if x % 2 == 0]

Demetler (Tuples)

Sabit boyutlu, farklı tipli elemanlar.

Oluşturma

değişken konum = (41.0, 29.0)
değişken kişi = ("Ahmet", 30, "İstanbul")
değişken tek_eleman = (42,)  // Virgül gerekli

Erişim

yazdır(konum.0)   // 41.0
yazdır(kişi.1)    // 30

Destructuring

değişken (lat, lon) = konum
değişken (isim, yaş, şehir) = kişi

yazdır(isim)   // Ahmet
yazdır(yaş)    // 30

Çoklu Dönüş

işlev min_max(liste: Liste<Sayı>) -> (Sayı, Sayı) {
    değişken min = liste[0]
    değişken max = liste[0]
    
    döngü n listede {
        eğer n < min { min = n }
        eğer n > max { max = n }
    }
    
    geri dön (min, max)
}

değişken (minimum, maksimum) = min_max([3, 1, 4, 1, 5])

Named Tuples

tür Nokta = tuple {
    x: Sayı,
    y: Sayı
}

değişken p = Nokta(x: 10, y: 20)
yazdır(p.x, p.y)

Struct Yapıları

Özel veri tipleri tanımlama.

Tanımlama

tür Kişi = struct {
    ad: Yazı,
    yaş: Sayı,
    email: Yazı
}

Instance Oluşturma

değişken kişi = Kişi {
    ad: "Ahmet",
    yaş: 30,
    email: "ahmet@example.com"
}

Alan Erişimi

yazdır(kişi.ad)      // Ahmet
yazdır(kişi.yaş)     // 30

kişi.yaş = 31         // Güncelleme

Metodlar

tür Dikdörtgen = struct {
    genişlik: Sayı,
    yükseklik: Sayı
}

impl Dikdörtgen {
    işlev alan(self) -> Sayı {
        geri dön self.genişlik * self.yükseklik
    }
    
    işlev çevre(self) -> Sayı {
        geri dön 2 * (self.genişlik + self.yükseklik)
    }
}

değişken dikdörtgen = Dikdörtgen { genişlik: 10, yükseklik: 5 }
yazdır(dikdörtgen.alan())    // 50
yazdır(dikdörtgen.çevre())  // 30

Varsayılan Değerler

tür Ayarlar = struct {
    tema: Yazı = "koyu",
    dil: Yazı = "tr",
    boyut: Sayı = 14
}

değişken ayar1 = Ayarlar {}  // Tüm varsayılanlar
değişken ayar2 = Ayarlar { tema: "açık" }  // Sadece tema değişti

Nested Structs

tür Adres = struct {
    cadde: Yazı,
    şehir: Yazı
}

tür Kullanıcı = struct {
    ad: Yazı,
    adres: Adres
}

değişken kullanıcı = Kullanıcı {
    ad: "Ali",
    adres: Adres {
        cadde: "Merkez Caddesi",
        şehir: "İstanbul"
    }
}

yazdır(kullanıcı.adres.şehir)  // İstanbul

Hata Yönetimi

BERK'te güvenli hata yönetimi.

Try-Catch Blokları

Hata yakalama:

deneme {
    riski_işlem()
} yakala e {
    yazdır("Hata: ", e)
}

Hata Türleri

Result ve Option tipleri:

tür Sonuç<T, E> = enum {
    Tamam(T),
    Hata(E)
}

Hata Yönetim Stratejileri

1. Result Tipi: Fonksiyon dönüşü
2. Try-Catch: Exception handling
3. Option: Null yerine
4. Panic: Kurtarılamaz hatalar

Try-Catch Blokları

Hata yakalama mekanizması.

Temel Kullanım

deneme {
    değişken dosya = dosya_aç("veri.txt")
    yazdır(dosya.oku())
} yakala e {
    yazdır("Hata oluştu: ", e)
}

İngilizce:

try {
    var file = open_file("data.txt")
    print(file.read())
} catch e {
    print("Error: ", e)
}

Çoklu Catch

deneme {
    riskli_işlem()
} yakala DosyaBulunamadıHatası e {
    yazdır("Dosya bulunamadı")
} yakala İzinHatası e {
    yazdır("İzin reddedildi")
} yakala e {
    yazdır("Bilinmeyen hata: ", e)
}

Finally Bloğu

deneme {
    dosya = dosya_aç("veri.txt")
    işle(dosya)
} yakala e {
    yazdır("Hata: ", e)
} sonunda {
    dosya.kapat()  // Her zaman çalışır
}

Hata Fırlatma

işlev kontrol_et(yaş: Sayı) {
    eğer yaş < 0 {
        fırlat "Yaş negatif olamaz"
    }
    eğer yaş > 150 {
        fırlat GeçersizDeğerHatası("Yaş çok büyük")
    }
}

Hata Türleri

Result Tipi

Başarı veya hata döndüren fonksiyonlar:

tür Sonuç<T, E> = enum {
    Tamam(T),
    Hata(E)
}

işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
    eğer b == 0 {
        hata dön "Sıfıra bölme"
    }
    tamam dön a / b
}

eş böl(10, 2) {
    Tamam(x) => yazdır("Sonuç: ", x),
    Hata(e) => yazdır("Hata: ", e)
}

Option Tipi

Değer olabilir veya olmayabilir:

tür Seçenek<T> = enum {
    Bazı(T),
    Hiç
}

işlev bul(liste: Liste<Sayı>, değer: Sayı) -> Seçenek<Sayı> {
    döngü (i, x) listede {
        eğer x == değer {
            geri dön Bazı(i)
        }
    }
    geri dön Hiç
}

Özel Hata Tipleri

tür DosyaHatası = enum {
    Bulunamadı(Yazı),
    İzinReddedildi,
    Okuma Hatası(Yazı)
}

işlev dosya_oku(yol: Yazı) -> Sonuç<Yazı, DosyaHatası> {
    eğer !dosya_var(yol) {
        hata dön DosyaHatası.Bulunamadı(yol)
    }
    // ...
}

Unwrap Metodları

// Panic atar eğer hata varsa
değişken değer = sonuç.unwrap()

// Varsayılan değer kullan
değişken değer = sonuç.unwrap_or(0)

// Hata dönüştür
değişken değer = sonuç.expect("Hesaplama başarısız")

Modüller ve Organizasyon

Modül Sistemi

Import ve Export

İki Dilli Syntax (Türkçe/İngilizce)

Bellek Güvenliği

Tip Sistemi

String İşlemleri

BERK Derleyicisi

Derleme Süreci

Optimizasyon Seviyeleri

Cross-Compilation

REPL - Etkileşimli Kabuk

VS Code Eklentisi

Hata Ayıklama

Örnek Programlar

BERK ile pratik uygulama örnekleri.

[İçerik]

• Basit Hesaplamalar - Matematik işlemleri
• String İşlemleri - Metin işleme
• Dosya İşlemleri - Dosya okuma/yazma
• Web Sunucu - HTTP sunucu

Hızlı Örnekler

Hello World

işlev ana() {
    yazdır("Merhaba Dünya!")
}

Fibonacci

işlev fib(n: Sayı) -> Sayı {
    eğer n <= 1 { geri dön n }
    geri dön fib(n-1) + fib(n-2)
}

Dosya Okuma

import fs

değişken içerik = fs.oku("data.txt")
yazdır(içerik)

Basit Hesaplamalar

Hesap Makinesi

işlev topla(a: Sayı, b: Sayı) -> Sayı { geri dön a + b }
işlev çıkar(a: Sayı, b: Sayı) -> Sayı { geri dön a - b }
işlev çarp(a: Sayı, b: Sayı) -> Sayı { geri dön a * b }
işlev böl(a: Sayı, b: Sayı) -> Sayı { geri dön a / b }

işlev ana() {
    değişken x = 10.0
    değişken y = 3.0
    
    yazdır("Toplam: ", topla(x, y))
    yazdır("Çarpım: ", çarp(x, y))
    yazdır("Bölüm: ", böl(x, y))
}

Faktoriyel

işlev faktoriyel(n: Sayı) -> Sayı {
    eğer n <= 1 {
        geri dön 1
    }
    geri dön n * faktoriyel(n - 1)
}

işlev ana() {
    döngü i 1'den 11'e {
        yazdır(i, "! = ", faktoriyel(i))
    }
}

Asal Sayı Kontrolü

işlev asal_mi(n: Sayı) -> Boolean {
    eğer n < 2 { geri dön yanlış }
    
    döngü i 2'den n'ye {
        eğer i * i > n { kır }
        eğer n % i == 0 { geri dön yanlış }
    }
    
    geri dön doğru
}

işlev ana() {
    yazdır("1-100 arası asal sayılar:")
    döngü n 1'den 101'e {
        eğer asal_mi(n) {
            yazdır(n, " ")
        }
    }
}

String İşlemleri

Metin Analizi

import string

işlev kelime_sayısı(metin: Yazı) -> Sayı {
    değişken kelimeler = metin.böl(" ")
    geri dön kelimeler.uzunluk
}

işlev ana() {
    değişken metin = "BERK modern bir programlama dilidir"
    
    yazdır("Kelime sayısı: ", kelime_sayısı(metin))
    yazdır("Karakter sayısı: ", metin.uzunluk)
    yazdır("Büyük harf: ", metin.büyük_harf())
}

Palindrom Kontrolü

işlev palindrom_mu(metin: Yazı) -> Boolean {
    değişken temiz = metin.küçük_harf().sadece_harf()
    değişken ters = temiz.ters()
    geri dön temiz == ters
}

işlev ana() {
    değişken kelimeler = ["kayak", "radar", "merhaba", "ey edip adana da pide ye"]
    
    döngü kelime kelimelerde {
        eğer palindrom_mu(kelime) {
            yazdır(kelime, " bir palindromdur")
        }
    }
}

Metin Formatlama

import fmt

işlev ana() {
    değişken isim = "Ahmet"
    değişken yaş = 25
    değişken maaş = 12500.50
    
    yazdır(fmt.format("Ad: {}, Yaş: {}, Maaş: {:.2f} TL", isim, yaş, maaş))
}

Dosya İşlemleri

Dosya Okuma

import fs

işlev ana() {
    deneme {
        değişken içerik = fs.oku("veri.txt")
        yazdır(içerik)
    } yakala e {
        yazdır("Dosya okuma hatası: ", e)
    }
}

Dosya Yazma

import fs

işlev ana() {
    değişken içerik = "Merhaba Dünya!"
    
    deneme {
        fs.yaz("çıktı.txt", içerik)
        yazdır("Dosya başarıyla yazıldı")
    } yakala e {
        yazdır("Yazma hatası: ", e)
    }
}

Satır Satır Okuma

import fs

işlev ana() {
    değişken satırlar = fs.satırlar_oku("log.txt")
    
    döngü (numara, satır) satırlarda {
        yazdır("Satır ", numara, ": ", satır)
    }
}

Dizin İşlemleri

import fs

işlev ana() {
    // Dizin oluştur
    fs.dizin_oluştur("yeni_klasör")
    
    // Dosyaları listele
    değişken dosyalar = fs.listele(".")
    döngü dosya dosyalarda {
        yazdır(dosya)
    }
    
    // Dosya var mı?
    eğer fs.var("config.json") {
        yazdır("Config bulundu")
    }
}

Web Sunucu Örneği

Basit HTTP Sunucu

import http

işlev ana() {
    değişken sunucu = http.sunucu_oluştur()
    
    sunucu.rota("/", (istek, yanıt) => {
        yanıt.gönder("Merhaba Dünya!")
    })
    
    sunucu.rota("/api/zaman", (istek, yanıt) => {
        değişken şimdi = time.now()
        yanıt.json({ "zaman": şimdi })
    })
    
    yazdır("Sunucu başlatıldı: http://localhost:3000")
    sunucu.dinle(3000)
}

REST API

import http, json

tür Kullanıcı = struct {
    id: Sayı,
    ad: Yazı,
    email: Yazı
}

değişken kullanıcılar: Liste<Kullanıcı> = []

işlev ana() {
    değişken app = http.sunucu_oluştur()
    
    // Tüm kullanıcıları getir
    app.get("/api/kullanıcılar", (req, res) => {
        res.json(kullanıcılar)
    })
    
    // Yeni kullanıcı ekle
    app.post("/api/kullanıcılar", (req, res) => {
        değişken yeni = json.parse<Kullanıcı>(req.body)
        kullanıcılar.ekle(yeni)
        res.json(yeni)
    })
    
    app.dinle(8080)
}

WebSocket Örneği

import ws

işlev ana() {
    değişken sunucu = ws.sunucu_oluştur()
    
    sunucu.bağlantı((socket) => {
        yazdır("Yeni bağlantı")
        
        socket.mesaj((data) => {
            yazdır("Alındı: ", data)
            socket.gönder("Echo: " + data)
        })
    })
    
    sunucu.dinle(9000)
}

Standart Kütüphane v1.4

BERK Standart Kütüphanesi, modern yazılım geliştirme için gerekli tüm temel fonksiyonları sağlar. v1.4 sürümü ile bilimsel hesaplama odaklı önemli bir güncelleme yapılmıştır.

📊 İstatistikler

• 18 modül - Kapsamlı fonksiyonellik
• 286 KB - Optimize edilmiş boyut
• 600+ fonksiyon - Zengin API
• Sıfır bağımlılık - Sadece BERK ile yazılmış

🎯 Modül Kategorileri

1. Temel Modüller (Core)

Tüm BERK programlarının temel ihtiyaçlarını karşılar:

2. Sistem Programlama (System)

Düşük seviye sistem etkileşimi:

3. Fonksiyonel Programlama (Functional)

Julia ve Rust tarzı fonksiyonel programlama:

4. Bilimsel Hesaplama (Scientific Computing) 🔬

v1.4'ün yıldızı! Üniversite ve araştırma seviyesinde matematik:

🚀 Hızlı Başlangıç

Basit Kullanım

// Matematik
kullan math

değişken sonuç = math_sin(math_PI / 2.0)  // 1.0
değişken faktöriyel = math_factorial(5)     // 120

İteratörler

kullan iter

değişken sayılar = [1, 2, 3, 4, 5]
değişken kareler = iter_map(sayılar, fonksiyon(x) yap dön x * x son)
değişken toplam = iter_sum(kareler)  // 55

Doğrusal Cebir

kullan linalg

// 3×3 birim matris
değişken I = linalg_birim_mat(3)

// Matris çarpımı
değişken A = [1.0, 2.0, 3.0, 4.0]  // 2×2
değişken B = [5.0, 6.0, 7.0, 8.0]
değişken C = linalg_mat_çarp(A, B, 2, 2, 2)

İstatistik

kullan stats

değişken data = [1.5, 2.3, 3.1, 4.8, 5.2]
değişken ortalama = stats_ortalama(data, 5)       // 3.38
değişken std_dev = stats_standart_sapma(data, 5)  // 1.52
değişken medyan = stats_medyan(data, 5)           // 3.1

Optimizasyon

kullan optim

// f(x) = x² - 4x + 4 fonksiyonunun minimumunu bul
fonksiyon f(x: ondalık): ondalık yap
    dön x * x - 4.0 * x + 4.0
son

değişken minimum = optim_golden_section(f, 0.0, 5.0, 0.001)
// minimum ≈ 2.0

📚 Detaylı Dokümantasyon

Her modül için detaylı dokümantasyon ayrı sayfalarda bulunmaktadır:

Temel Modüller

• io - Giriş/Çıkış
• string - String İşlemleri
• collections - Koleksiyonlar
• result - Hata Yönetimi
• time - Zaman İşlemleri

Sistem Programlama

• fs - Dosya Sistemi
• thread - Çoklu İş Parçacığı
• sys - Sistem Bilgisi
• terminal - Terminal Kontrolü

Fonksiyonel Programlama

• iter - İteratörler
• fmt - Gelişmiş Formatlama

Bilimsel Hesaplama

• math - Matematik
• physics - Fizik
• complex - Kompleks Sayılar
• random - Rastgele Sayılar
• linalg - Doğrusal Cebir
• stats - İstatistik
• optim - Optimizasyon

🎓 Kullanım Senaryoları

Bilimsel Araştırma

// İstatistiksel analiz
değişken veriler = veri_oku("deney.csv")
değişken ortalama = stats_ortalama(veriler)
değişken t_skoru = stats_t_score(veriler, 0.0)

// Hipotez testi
eğer math_mutlak(t_skoru) > 2.0 ise yap
    yazdır("İstatistiksel olarak anlamlı!")
son

Makine Öğrenmesi Temelleri

// Doğrusal regresyon
değişken X = [1.0, 2.0, 3.0, 4.0, 5.0]
değişken y = [2.1, 3.9, 6.2, 8.1, 9.8]

değişken (a, b, r2) = stats_linear_regression(X, y, 5)
yazdır("y = " + a + " + " + b + "x")
yazdır("R² = " + r2)

Nümerik Simülasyon

// Monte Carlo π tahmini
kullan random

değişken içerde = 0
değişken toplam = 1000000

değişken rng = random_xoshiro_seed(12345)

değişken i = 0
iken (i < toplam) yap
    değişken x = random_xoshiro_next_float(rng)
    değişken y = random_xoshiro_next_float(rng)
    
    eğer (x*x + y*y < 1.0) ise yap
        içerde = içerde + 1
    son
    
    i = i + 1
son

değişken pi_tahmini = 4.0 * içerde / toplam
yazdır("π ≈ " + pi_tahmini)  // ~3.14159

Optimizasyon Problemleri

// Gradyan inişi ile fonksiyon minimizasyonu
kullan optim
kullan linalg

// f(x, y) = x² + y² - 2x - 4y + 5
fonksiyon gradyan(pos: [ondalık], n: tam_sayı): [ondalık] yap
    değişken grad = [2.0 * pos[0] - 2.0, 2.0 * pos[1] - 4.0]
    dön grad
son

değişken başlangıç = [0.0, 0.0]
değişken minimum = optim_gradient_descent(gradyan, başlangıç, 2, 0.1, 100, 0.001)

yazdır("Minimum nokta: (" + minimum[0] + ", " + minimum[1] + ")")
// Beklenen: (1.0, 2.0)

🔧 Implementation Status

Durum Açıklaması:

• ✅ Tamamen tasarlandı ve API hazır
• ⏳ Backend implementasyonu devam ediyor
• 🔄 Aktif geliştirme

🎯 v1.5 Roadmap

Gelecek sürümde planlanan geliştirmeler:

1. signal - Sinyal işleme (FFT, filtering, spectral analysis)
2. ml - Makine öğrenmesi (neural networks, gradient descent)
3. plot - Veri görselleştirme (2D/3D plotting)
4. sparse - Seyrek matrisler (COO, CSR, CSC formats)
5. ode - Diferansiyel denklemler (RK4, BDF, adaptive)

📖 Daha Fazla Bilgi

• GitHub Repository
• API Reference
• Contributing Guide
• Changelog

Hazır mısınız? Bir sonraki bölümde modülleri detaylı olarak inceleyelim!

io - Giriş/Çıkış

Modül: io.berk (12 KB)
Kategori: Sistem / I/O
Fonksiyonlar: 64

🚀 Hızlı Başlangıç

içe_aktar io

// Dosya okuma
değişken içerik = io.dosya_oku("data.txt")
yazdır(içerik)

// Dosya yazma
io.dosya_yaz("output.txt", "Merhaba BERK!")

// Satır satır okuma
değişken satırlar = io.satırları_oku("data.txt")
için satır içinde satırlar yap
    yazdır(satır)
son

📚 Fonksiyon Kategorileri

Basit Dosya İşlemleri

dosya_oku(), dosya_yaz(), dosya_ekle(), satırları_oku()

Dosya Handle İşlemleri

aç(), kapat(), oku(), yaz(), flush()

Buffered I/O

buffered_reader(), buffered_writer(), satır_oku(), buffer_flush()

Console I/O

yazdır(), yazdır_satır(), hata_yazdır(), girdi_al()

Binary I/O

bayt_oku(), bayt_yaz(), seek(), tell()

string - String İşlemleri

Modül: string.berk
Fonksiyonlar: String manipülasyonu, arama, format, encoding

Temel Fonksiyonlar

uzunluk(), büyük_harf(), küçük_harf(), trim(), split(), join(), replace(), contains()

collections - Koleksiyonlar

Modül: collections.berk
Fonksiyonlar: Veri yapıları (Vector, HashMap, HashSet, LinkedList)

Veri Yapıları

Vec, HashMap, HashSet, LinkedList, BTreeMap, Queue, Stack

result - Hata Yönetimi

Modül: result.berk
Fonksiyonlar: Result<T, E> ve Option<T> tipleri

Temel Tipler

Result::Ok(), Result::Err(), Option::Some(), Option::None(), unwrap(), expect()

time - Zaman İşlemleri

Modül: time.berk
Fonksiyonlar: Tarih/saat işlemleri, timestamp, duration

Temel Fonksiyonlar

şimdi(), timestamp(), sleep(), format(), parse(), diff()

fs - Dosya Sistemi

Modül: fs.berk
Fonksiyonlar: Dosya/dizin operasyonları, metadata, permissions

Temel Fonksiyonlar

exists(), create_dir(), remove(), copy(), move(), metadata(), list_dir()

thread - Çoklu İş Parçacığı

Modül: thread.berk
Fonksiyonlar: Thread oluşturma, senkronizasyon, mutex, channels

Temel Fonksiyonlar

spawn(), join(), sleep(), Mutex, Channel, Arc

sys - Sistem Bilgisi

Modül: sys.berk
Fonksiyonlar: OS bilgisi, environment variables, process info

Temel Fonksiyonlar

os(), arch(), env_get(), env_set(), pid(), exit()

terminal - Terminal Kontrolü

Modül: terminal.berk
Fonksiyonlar: Terminal renklendirme, cursor kontrolü, input

Temel Fonksiyonlar

clear(), color(), cursor_pos(), size(), read_key()

iter - İteratörler

Modül: iter.berk
Fonksiyonlar: Iterator patterns, map, filter, reduce

Temel Fonksiyonlar

map(), filter(), fold(), zip(), enumerate(), collect()

fmt - Gelişmiş Formatlama

Modül: fmt.berk
Fonksiyonlar: String formatting, printf-style, templates

Temel Fonksiyonlar

format(), sprintf(), pad(), align(), number_format()

math - Matematik

Modül: math.berk (40.9 KB)
Fonksiyonlar: 143 (trigonometry, calculus, special functions)

Kategoriler

sin(), cos(), tan(), exp(), log(), sqrt(), pow(), factorial(), gcd(), lcm()

physics - Fizik

Modül: physics.berk (28.5 KB)
Fonksiyonlar: Fizik sabitleri, birim dönüşümleri, kinematik

Temel Fonksiyonlar

Fizik sabitleri (c, G, h, k), birim dönüşümleri, kinematik hesaplamalar

complex - Kompleks Sayılar

Modül: complex.berk (14.5 KB)
Fonksiyonlar: Kompleks sayı aritmetiği, polar form, trigonometry

Temel Fonksiyonlar

Complex tipi, add(), mul(), abs(), arg(), conjugate(), polar()

random - Rastgele Sayılar

Modül: random.berk (32.5 KB)
Fonksiyonlar: PRNG, distributions (uniform, normal, exponential)

Temel Fonksiyonlar

rand(), seed(), uniform(), normal(), choice(), shuffle()

linalg - Doğrusal Cebir

Modül: linalg.berk (25.4 KB)
Kategori: Bilimsel Hesaplama
Inspiration: Julia LinearAlgebra, NumPy, Rust nalgebra, BLAS/LAPACK

📋 Genel Bakış

linalg modülü, matris ve vektör işlemleri için kapsamlı bir doğrusal cebir kütüphanesidir. Üniversite seviyesinde matematik ve mühendislik uygulamaları için tasarlanmıştır.

Özellikler:

• ✅ Matris oluşturma ve temel işlemler
• ✅ Matris aritmetiği (toplama, çarpma, transpoze)
• ✅ Vektör işlemleri (dot, cross, norm)
• ✅ Matris ayrıştırmaları (LU, QR, Cholesky)
• ✅ Özdeğer/özvektör hesaplama
• ✅ Doğrusal sistem çözücüler
• ✅ Matris normları ve özellikleri

🎯 Hızlı Başlangıç

Matris Oluşturma

kullan linalg

// 3×3 birim matris
değişken I = linalg_birim_mat(3)

// Sıfır matrisi
değişken Z = linalg_sıfır_mat(2, 3)

// Birler matrisi
değişken O = linalg_birler_mat(4, 4)

// Diyagonal matris
değişken d = [1.0, 2.0, 3.0]
değişken D = linalg_diyagonal_mat(d, 3)

// Rastgele matris
değişken R = linalg_rastgele_mat(3, 3, 12345)

Matris İşlemleri

// Transpoze
değişken A = [1.0, 2.0, 3.0, 4.0]  // 2×2
değişken AT = linalg_transpoz(A, 2, 2)

// Matris toplama
değişken C = linalg_mat_topla(A, B, 2, 2)

// Skaler çarpma
değişken D = linalg_mat_skaler(2.0, A, 2, 2)

// Matris çarpımı (A: 2×3, B: 3×2 → C: 2×2)
değişken C = linalg_mat_çarp(A, B, 2, 3, 2)

📚 API Referansı

Matris Oluşturma

linalg_birim_mat(n: tam_sayı) -> [ondalık]

n×n boyutunda birim (identity) matris oluşturur.

Parametre:

• n: Matris boyutu

Döndürür: Birim matris (düz dizi formatında)

Örnek:

değişken I3 = linalg_birim_mat(3)
// I3 = [1, 0, 0,
//       0, 1, 0,
//       0, 0, 1]

linalg_sıfır_mat(m: tam_sayı, n: tam_sayı) -> [ondalık]

m×n boyutunda sıfır matrisi oluşturur.

linalg_birler_mat(m: tam_sayı, n: tam_sayı) -> [ondalık]

m×n boyutunda tüm elemanları 1 olan matris oluşturur.

linalg_diyagonal_mat(d: [ondalık], n: tam_sayı) -> [ondalık]

Köşegen elemanları d dizisi olan n×n matris oluşturur.

Örnek:

değişken d = [2.0, 3.0, 5.0]
değişken D = linalg_diyagonal_mat(d, 3)
// D = [2, 0, 0,
//      0, 3, 0,
//      0, 0, 5]

Matris Aritmetiği

linalg_mat_topla(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

İki m×n matrisini toplar: C = A + B

linalg_mat_çıkar(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

İki m×n matrisini çıkarır: C = A - B

linalg_mat_skaler(α: ondalık, A: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Matrisi skaler ile çarpar: B = α · A

linalg_mat_çarp(A: [ondalık], B: [ondalık], m: tam_sayı, k: tam_sayı, n: tam_sayı) -> [ondalık]

Matris çarpımı: C = A × B

• A: m×k
• B: k×n
• C: m×n

Örnek:

// 2×2 matris çarpımı
değişken A = [1.0, 2.0,
              3.0, 4.0]
değişken B = [5.0, 6.0,
              7.0, 8.0]
değişken C = linalg_mat_çarp(A, B, 2, 2, 2)
// C = [19, 22,
//      43, 50]

linalg_mat_hadamard(A: [ondalık], B: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Element-wise çarpım (Hadamard product): C[i,j] = A[i,j] × B[i,j]

Vektör İşlemleri

linalg_iç_çarpım(u: [ondalık], v: [ondalık], n: tam_sayı) -> ondalık

İç çarpım (dot product): u · v = Σ(u[i] × v[i])

Örnek:

değişken u = [1.0, 2.0, 3.0]
değişken v = [4.0, 5.0, 6.0]
değişken dot = linalg_iç_çarpım(u, v, 3)  // 32.0

linalg_norm2(v: [ondalık], n: tam_sayı) -> ondalık

L2 norm (Euclidean norm): ||v|| = √(Σv[i]²)

linalg_norm1(v: [ondalık], n: tam_sayı) -> ondalık

L1 norm (Manhattan norm): ||v||₁ = Σ|v[i]|

linalg_norm_inf(v: [ondalık], n: tam_sayı) -> ondalık

L∞ norm (maximum norm): ||v||∞ = max(|v[i]|)

linalg_normalize(v: [ondalık], n: tam_sayı) -> [ondalık]

Vektörü normalize eder: v̂ = v / ||v||

linalg_dış_çarpım(u: [ondalık], v: [ondalık], m: tam_sayı, n: tam_sayı) -> [ondalık]

Dış çarpım (outer product): A[i,j] = u[i] × v[j]

linalg_cross_3d(u: [ondalık], v: [ondalık]) -> [ondalık]

3D vektör cross product (vektörel çarpım): w = u × v

Örnek:

değişken u = [1.0, 0.0, 0.0]
değişken v = [0.0, 1.0, 0.0]
değişken w = linalg_cross_3d(u, v)  // [0, 0, 1]

Matris Özellikleri

linalg_iz(A: [ondalık], n: tam_sayı) -> ondalık

İz (trace): tr(A) = Σ A[i,i]

linalg_frobenius_norm(A: [ondalık], m: tam_sayı, n: tam_sayı) -> ondalık

Frobenius norm: ||A||_F = √(Σ Σ A[i,j]²)

linalg_determinant_2x2(A: [ondalık]) -> ondalık

2×2 matris determinantı: det(A) = a₁₁a₂₂ - a₁₂a₂₁

linalg_determinant_3x3(A: [ondalık]) -> ondalık

3×3 matris determinantı (Sarrus kuralı)

Matris Tersi

linalg_inverse_2x2(A: [ondalık]) -> [ondalık]

2×2 matris tersini hesaplar: A⁻¹

Örnek:

değişken A = [4.0, 7.0,
              2.0, 6.0]
değişken A_inv = linalg_inverse_2x2(A)
// det(A) = 10
// A_inv = [0.6, -0.7,
//         -0.2,  0.4]

linalg_inverse_3x3(A: [ondalık]) -> [ondalık]

3×3 matris tersini hesaplar (cofactor expansion)

Doğrusal Sistemler

linalg_gauss_çöz(A: [ondalık], b: [ondalık], n: tam_sayı) -> [ondalık]

Ax = b doğrusal sistemini Gauss eliminasyonu ile çözer.

Özellikler:

• Partial pivoting
• Forward elimination
• Back substitution

Örnek:

// 3x + 2y = 7
// 2x + 5y = 12
değişken A = [3.0, 2.0,
              2.0, 5.0]
değişken b = [7.0, 12.0]
değişken x = linalg_gauss_çöz(A, b, 2)
// x = [1, 2]

Matris Ayrıştırmaları

linalg_lu_decompose(A: [ondalık], n: tam_sayı) -> [ondalık]

LU ayrıştırması: A = L × U

• L: Alt üçgen matris (köşegeni 1)
• U: Üst üçgen matris

Kullanım: Doğrusal sistemleri hızlı çözmek için

linalg_qr_gram_schmidt(A: [ondalık], m: tam_sayı, n: tam_sayı) -> ([ondalık], [ondalık])

QR ayrıştırması: A = Q × R

• Q: Ortogonal matris
• R: Üst üçgen matris

Algoritma: Gram-Schmidt orthogonalization

Döndürür: (Q, R) tuple'ı

linalg_cholesky(A: [ondalık], n: tam_sayı) -> [ondalık]

Cholesky ayrıştırması: A = L × Lᵀ

Gereksinim: A pozitif tanımlı simetrik matris olmalı

Kullanım: Kovaryans matrisleri, optimization

Özdeğer/Özvektör

linalg_power_iteration(A: [ondalık], n: tam_sayı, max_iter: tam_sayı, tolerans: ondalık) -> ([ondalık], ondalık)

Güç iterasyonu ile dominant eigenvector bulma.

Döndürür: (eigenvector, eigenvalue) tuple'ı

Örnek:

değişken A = [4.0, 1.0,
              1.0, 3.0]
değişken (v, λ) = linalg_power_iteration(A, 2, 100, 1e-6)
// λ ≈ 4.618 (dominant eigenvalue)
// v: karşılık gelen eigenvector

Matris Testleri

linalg_simetrik_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Matrisin simetrik olup olmadığını kontrol eder: Aᵢⱼ = Aⱼᵢ

linalg_diagonal_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Diyagonal matris kontrolü

linalg_üst_üçgen_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Üst üçgen matris kontrolü

linalg_alt_üçgen_mi(A: [ondalık], n: tam_sayı, tolerans: ondalık) -> mantıksal

Alt üçgen matris kontrolü

Matris Rankı

linalg_rank(A: [ondalık], m: tam_sayı, n: tam_sayı, tolerans: ondalık) -> tam_sayı

Matris rankını Gaussian elimination ile hesaplar.

Örnek:

değişken A = [1.0, 2.0, 3.0,
              2.0, 4.0, 6.0,
              3.0, 6.0, 9.0]
değişken r = linalg_rank(A, 3, 3, 1e-10)  // r = 1

🔬 Kullanım Örnekleri

Örnek 1: Doğrusal Regresyon

kullan linalg
kullan stats

// y = ax + b modelini fit et
fonksiyon linear_fit(X: [ondalık], y: [ondalık], n: tam_sayı): (ondalık, ondalık) yap
    // X matrix: [ones, x_values]
    değişken A = yeni_dizi(n * 2)
    değişken i = 0
    iken (i < n) yap
        A[i * 2] = 1.0
        A[i * 2 + 1] = X[i]
        i = i + 1
    son
    
    // Normal equations: (A^T A) β = A^T y
    değişken params = linalg_least_squares(A, y, n, 2)
    dön (params[0], params[1])  // (b, a)
son

Örnek 2: PCA (Principal Component Analysis)

kullan linalg

// Veriyi merkeze al
fonksiyon center_data(data: [ondalık], m: tam_sayı, n: tam_sayı): [ondalık] yap
    değişken centered = linalg_mat_kopyala(data, m, n)
    
    // Her sütun için ortalamayı çıkar
    değişken j = 0
    iken (j < n) yap
        değişken ortalama = 0.0
        değişken i = 0
        iken (i < m) yap
            ortalama = ortalama + linalg_mat_al(data, i, j, n)
            i = i + 1
        son
        ortalama = ortalama / m
        
        i = 0
        iken (i < m) yap
            değişken değer = linalg_mat_al(centered, i, j, n) - ortalama
            linalg_mat_yaz(centered, i, j, n, değer)
            i = i + 1
        son
        
        j = j + 1
    son
    
    dön centered
son

// Kovaryans matrisini hesapla
fonksiyon covariance_matrix(data: [ondalık], m: tam_sayı, n: tam_sayı): [ondalık] yap
    değişken centered = center_data(data, m, n)
    değişken CT = linalg_transpoz(centered, m, n)
    değişken cov = linalg_mat_çarp(CT, centered, n, m, n)
    
    // (n-1) ile böl
    değişken i = 0
    iken (i < n * n) yap
        cov[i] = cov[i] / (m - 1)
        i = i + 1
    son
    
    dön cov
son

Örnek 3: Matris Normu ve Condition Number

kullan linalg

fonksiyon analyze_matrix(A: [ondalık], n: tam_sayı): hiçbir yap
    // Frobenius norm
    değişken norm = linalg_frobenius_norm(A, n, n)
    yazdır("||A||_F = " + norm)
    
    // Determinant
    eğer (n == 2) ise yap
        değişken det = linalg_determinant_2x2(A)
        yazdır("det(A) = " + det)
        
        // Inverse ve condition number
        eğer (math_mutlak(det) > 1e-10) ise yap
            değişken A_inv = linalg_inverse_2x2(A)
            değişken κ = linalg_condition_frobenius(A, A_inv, n)
            yazdır("κ(A) = " + κ)
            
            eğer (κ > 100.0) ise yap
                yazdır("UYARI: Matris kötü koşullu!")
            son
        son
    son
    
    // Simetri kontrolü
    eğer (linalg_simetrik_mi(A, n, 1e-10)) ise yap
        yazdır("Matris simetriktir")
    son
son

⚡ Performans Notları

Kompleksite

Optimizasyon İpuçları

1. BLAS/LAPACK Kullanın (gelecek sürüm):

   // Native BLAS matris çarpımı
   değişken C = linalg_gemm_blas(A, B, m, k, n)
   

2. Seyrek Matrisler için özel algoritmalar (v1.5):

   kullan sparse
   değişken A_sparse = sparse_csr(A, m, n)
   

3. GPU Acceleration (planlanan):

   kullan cuda
   değişken C = cuda_matmul(A, B, m, k, n)
   

🔗 İlgili Modüller

• stats - İstatistiksel hesaplamalar için linalg kullanır
• optim - Optimizasyon algoritmaları için matris işlemleri
• math - Temel matematik fonksiyonları

📖 Daha Fazla Bilgi

• Julia LinearAlgebra
• NumPy Linear Algebra
• Rust nalgebra
• LAPACK User Guide

stats - İstatistik ve Olasılık

Modül: stats.berk (24.5 KB)
Kategori: Bilimsel Hesaplama
Inspiration: Julia Statistics, SciPy.stats, R

📋 Genel Bakış

stats modülü, modern istatistiksel analiz için kapsamlı fonksiyonlar sunar. Veri bilimi, makine öğrenmesi ve bilimsel araştırma için tasarlanmıştır.

Özellikler:

• ✅ Tanımlayıcı istatistikler (mean, median, std dev, moments)
• ✅ Quantile ve percentile hesaplama
• ✅ Korelasyon ve kovaryans
• ✅ Hipotez testleri (t-test, chi-square, ANOVA)
• ✅ Olasılık dağılımları (PDF, CDF)
• ✅ Doğrusal regresyon
• ✅ Yeniden örnekleme (bootstrap, jackknife)
• ✅ Non-parametric testler

🎯 Hızlı Başlangıç

Temel İstatistikler

kullan stats

değişken data = [2.5, 3.1, 4.8, 5.2, 6.0, 7.3, 8.1]
değişken n = 7

// Merkez eğilimi ölçüleri
değişken mean = stats_ortalama(data, n)           // 5.29
değişken median = stats_medyan(data, n)           // 5.2
değişken mode = stats_mod(data, n, 0.1)          // En sık değer

// Yayılım ölçüleri
değişken variance = stats_varyans(data, n)        // 3.68
değişken std_dev = stats_standart_sapma(data, n) // 1.92
değişken range = stats_aralık(data, n)           // 5.6

📚 API Referansı

Tanımlayıcı İstatistikler

Merkez Eğilimi

stats_ortalama(data: [ondalık], n: tam_sayı) -> ondalık

Aritmetik ortalama: x̄ = (Σxᵢ) / n

stats_ağırlıklı_ortalama(data: [ondalık], weights: [ondalık], n: tam_sayı) -> ondalık

Ağırlıklı ortalama: x̄ = (Σwᵢxᵢ) / (Σwᵢ)

Örnek:

değişken notlar = [70.0, 80.0, 90.0]
değişken ağırlıklar = [0.2, 0.3, 0.5]  // %20, %30, %50
değişken ort = stats_ağırlıklı_ortalama(notlar, ağırlıklar, 3)  // 82.0

stats_geometrik_ortalama(data: [ondalık], n: tam_sayı) -> ondalık

Geometrik ortalama: ⁿ√(x₁ × x₂ × ... × xₙ)

Kullanım: Büyüme oranları, indeksler

stats_harmonik_ortalama(data: [ondalık], n: tam_sayı) -> ondalık

Harmonik ortalama: n / (Σ(1/xᵢ))

Kullanım: Hızlar, oranlar

stats_medyan(data: [ondalık], n: tam_sayı) -> ondalık

Ortanca değer (50. percentile)

stats_mod(data: [ondalık], n: tam_sayı, tolerans: ondalık) -> ondalık

En sık görülen değer

Yayılım Ölçüleri

stats_varyans(data: [ondalık], n: tam_sayı) -> ondalık

Örneklem varyansı: s² = Σ(xᵢ - x̄)² / (n-1)

stats_popülasyon_varyansı(data: [ondalık], n: tam_sayı) -> ondalık

Popülasyon varyansı: σ² = Σ(xᵢ - μ)² / n

stats_standart_sapma(data: [ondalık], n: tam_sayı) -> ondalık

Standart sapma: s = √(varyans)

stats_ortalama_mutlak_sapma(data: [ondalık], n: tam_sayı) -> ondalık

MAD = (Σ|xᵢ - x̄|) / n

stats_aralık(data: [ondalık], n: tam_sayı) -> ondalık

Değişim aralığı: max - min

Quantile ve Percentile

stats_quantile(data: [ondalık], n: tam_sayı, p: ondalık) -> ondalık

p-quantile değerini hesaplar (0 ≤ p ≤ 1)

Örnek:

değişken data = [1.0, 2.0, 3.0, 4.0, 5.0]
değişken q1 = stats_quantile(data, 5, 0.25)  // 2.0 (1. çeyrek)
değişken q2 = stats_quantile(data, 5, 0.50)  // 3.0 (medyan)
değişken q3 = stats_quantile(data, 5, 0.75)  // 4.0 (3. çeyrek)

stats_percentile(data: [ondalık], n: tam_sayı, p: tam_sayı) -> ondalık

p-percentile (0-100 arası)

stats_iqr(data: [ondalık], n: tam_sayı) -> ondalık

Çeyrekler arası aralık: IQR = Q3 - Q1

Kullanım: Outlier tespiti

Momentler

stats_skewness(data: [ondalık], n: tam_sayı) -> ondalık

Çarpıklık (skewness): Dağılımın asimetrisi

• < 0: Sola çarpık
• = 0: Simetrik

• 0: Sağa çarpık

stats_kurtosis(data: [ondalık], n: tam_sayı) -> ondalık

Basıklık (kurtosis): Kuyruk kalınlığı

• < 0: Düz (platykurtic)
• = 0: Normal (mesokurtic)

• 0: Sivri (leptokurtic)

Örnek:

değişken data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
değişken skew = stats_skewness(data, 7)  // ≈ 0 (simetrik)
değişken kurt = stats_kurtosis(data, 7)  // Basıklık

Korelasyon ve Kovaryans

stats_covariance(x: [ondalık], y: [ondalık], n: tam_sayı) -> ondalık

Kovaryans: cov(X,Y) = Σ(xᵢ - x̄)(yᵢ - ȳ) / (n-1)

stats_correlation(x: [ondalık], y: [ondalık], n: tam_sayı) -> ondalık

Pearson korelasyon katsayısı: r = cov(X,Y) / (σₓσᵧ)

• -1: Mükemmel negatif korelasyon
• 0: Korelasyon yok
• +1: Mükemmel pozitif korelasyon

Örnek:

değişken boy = [160.0, 165.0, 170.0, 175.0, 180.0]
değişken kilo = [55.0, 60.0, 65.0, 75.0, 80.0]
değişken r = stats_correlation(boy, kilo, 5)  // ≈ 0.98 (güçlü pozitif)

stats_r_squared(x: [ondalık], y: [ondalık], n: tam_sayı) -> ondalık

Determinasyon katsayısı: R² = r²

Yorum: Varyansın açıklanan oranı

Doğrusal Regresyon

stats_linear_regression(x: [ondalık], y: [ondalık], n: tam_sayı) -> (ondalık, ondalık, ondalık)

Basit doğrusal regresyon: y = a + bx

Döndürür: (a, b, R²)

• a: Y-kesim noktası (intercept)
• b: Eğim (slope)
• R²: Belirlilik katsayısı

Örnek:

değişken X = [1.0, 2.0, 3.0, 4.0, 5.0]
değişken y = [2.1, 3.9, 6.2, 8.1, 9.8]

değişken (a, b, r2) = stats_linear_regression(X, y, 5)
yazdır("y = " + a + " + " + b + "x")
yazdır("R² = " + r2)
// y = 0.2 + 1.96x
// R² = 0.997

stats_predict_linear(x: ondalık, a: ondalık, b: ondalık) -> ondalık

Modelden tahmin: ŷ = a + bx

Hipotez Testleri

stats_t_score(data: [ondalık], n: tam_sayı, μ0: ondalık) -> ondalık

Tek örneklem t-skoru: t = (x̄ - μ₀) / (s / √n)

Örnek:

// H₀: μ = 100
değişken scores = [105.0, 110.0, 95.0, 108.0, 102.0]
değişken t = stats_t_score(scores, 5, 100.0)

eğer (math_mutlak(t) > 2.776) ise yap  // α = 0.05, df = 4
    yazdır("H₀ reddedildi!")
son

stats_t_test_independent(x: [ondalık], nx: tam_sayı, y: [ondalık], ny: tam_sayı) -> ondalık

İki bağımsız örneklem t-testi

Kullanım: İki grubun ortalamalarını karşılaştırma

stats_t_test_paired(x: [ondalık], y: [ondalık], n: tam_sayı) -> ondalık

Eşleştirilmiş t-testi

Kullanım: Önce-sonra karşılaştırmaları

stats_chi_square(observed: [ondalık], expected: [ondalık], k: tam_sayı) -> ondalık

Ki-kare testi: χ² = Σ((O - E)² / E)

Kullanım: Kategorik veri analizi, uyum iyiliği

stats_f_statistic(between_var: ondalık, within_var: ondalık) -> ondalık

F-istatistiği (ANOVA için)

Güven Aralıkları

stats_confidence_interval(data: [ondalık], n: tam_sayı, t_critical: ondalık) -> (ondalık, ondalık)

Ortalama için güven aralığı

Döndürür: (alt_sınır, üst_sınır)

Örnek:

değişken data = [23.0, 25.0, 27.0, 24.0, 26.0]
değişken t_crit = 2.776  // %95 güven, df=4
değişken (lower, upper) = stats_confidence_interval(data, 5, t_crit)
yazdır("95% CI: [" + lower + ", " + upper + "]")

stats_standard_error(data: [ondalık], n: tam_sayı) -> ondalık

Standart hata: SE = s / √n

Olasılık Dağılımları

PDF (Probability Density Function)

stats_normal_pdf(x: ondalık, μ: ondalık, σ: ondalık) -> ondalık

Normal dağılım PDF: f(x) = (1/(σ√(2π))) exp(-(x-μ)²/(2σ²))

stats_standard_normal_pdf(z: ondalık) -> ondalık

Standart normal (μ=0, σ=1)

stats_exponential_pdf(x: ondalık, λ: ondalık) -> ondalık

Üstel dağılım: f(x) = λe^(-λx)

stats_uniform_pdf(x: ondalık, a: ondalık, b: ondalık) -> ondalık

Uniform dağılım

CDF (Cumulative Distribution Function)

stats_normal_cdf(x: ondalık, μ: ondalık, σ: ondalık) -> ondalık

Normal dağılım CDF: P(X ≤ x)

Örnek:

// IQ testinde 110'dan düşük olma olasılığı
// IQ ~ N(100, 15)
değişken p = stats_normal_cdf(110.0, 100.0, 15.0)  // ≈ 0.747
yazdır("P(IQ ≤ 110) = " + (p * 100.0) + "%")

stats_standard_normal_cdf(z: ondalık) -> ondalık

Standart normal CDF

stats_exponential_cdf(x: ondalık, λ: ondalık) -> ondalık

Üstel dağılım CDF

Yeniden Örnekleme

stats_bootstrap_sample(data: [ondalık], n: tam_sayı, tohum: tam_sayı) -> [ondalık]

Bootstrap yeniden örnekleme (replacement ile)

Kullanım:

// Bootstrap güven aralığı
değişken data = [...]
değişken n_bootstrap = 1000
değişken means = yeni_dizi(n_bootstrap)

değişken i = 0
iken (i < n_bootstrap) yap
    değişken sample = stats_bootstrap_sample(data, n, i)
    means[i] = stats_ortalama(sample, n)
    i = i + 1
son

// %95 bootstrap CI
değişken ci_lower = stats_quantile(means, n_bootstrap, 0.025)
değişken ci_upper = stats_quantile(means, n_bootstrap, 0.975)

stats_jackknife_sample(data: [ondalık], n: tam_sayı, exclude_index: tam_sayı) -> [ondalık]

Jackknife yeniden örnekleme (bir eleman çıkarılmış)

Non-Parametric Testler

stats_mann_whitney_u(x: [ondalık], nx: tam_sayı, y: [ondalık], ny: tam_sayı) -> ondalık

Mann-Whitney U testi (rank-sum test)

Kullanım: Normal dağılmayan iki grup karşılaştırması

stats_wilcoxon_signed_rank(x: [ondalık], y: [ondalık], n: tam_sayı) -> ondalık

Wilcoxon signed-rank testi

Kullanım: Eşleştirilmiş non-parametric karşılaştırma

Histogram ve Binning

stats_histogram(data: [ondalık], n: tam_sayı, bin_sayısı: tam_sayı) -> [tam_sayı]

Histogram oluşturur (eşit genişlikte binler)

stats_sturges_bins(n: tam_sayı) -> tam_sayı

Sturges kuralı ile optimal bin sayısı: k = ⌈log₂(n) + 1⌉

Örnek:

değişken data = [1.2, 2.3, 1.8, 3.5, 2.1, ...]
değişken n = 100
değişken k = stats_sturges_bins(n)  // ≈ 8
değişken hist = stats_histogram(data, n, k)

Entropi

stats_entropy(probabilities: [ondalık], n: tam_sayı) -> ondalık

Shannon entropisi: H = -Σ(pᵢ log₂(pᵢ))

stats_kl_divergence(p: [ondalık], q: [ondalık], n: tam_sayı) -> ondalık

Kullback-Leibler divergence: D_KL(P||Q) = Σ pᵢ log(pᵢ/qᵢ)

Effect Sizes

stats_cohens_d(x: [ondalık], nx: tam_sayı, y: [ondalık], ny: tam_sayı) -> ondalık

Cohen's d effect size: d = (x̄ - ȳ) / s_pooled

Yorum:

• |d| < 0.2: Küçük
• |d| ≈ 0.5: Orta
• |d| > 0.8: Büyük

stats_hedges_g(x: [ondalık], nx: tam_sayı, y: [ondalık], ny: tam_sayı) -> ondalık

Hedge's g (düzeltilmiş Cohen's d)

Veri Normalizasyonu

stats_normalize(data: [ondalık], n: tam_sayı) -> [ondalık]

Z-score standardization: z = (x - μ) / σ

stats_min_max_normalize(data: [ondalık], n: tam_sayı) -> [ondalık]

Min-max normalizasyonu: x' = (x - min) / (max - min)

Outlier Tespiti

stats_is_outlier(x: ondalık, data: [ondalık], n: tam_sayı, multiplier: ondalık) -> mantıksal

IQR metoduyla outlier tespiti

Kural: x < Q1 - k·IQR veya x > Q3 + k·IQR (genellikle k=1.5)

Utilities

stats_cumsum(data: [ondalık], n: tam_sayı) -> [ondalık]

Kümülatif toplam

stats_moving_average(data: [ondalık], n: tam_sayı, pencere: tam_sayı) -> [ondalık]

Hareketli ortalama

🔬 Kullanım Örnekleri

Örnek 1: A/B Testi

kullan stats

// Versiyon A ve B'nin conversion rate'lerini karşılaştır
değişken groupA = [0.12, 0.15, 0.11, 0.13, 0.14]
değişken groupB = [0.18, 0.20, 0.17, 0.19, 0.21]

// t-testi
değişken t = stats_t_test_independent(groupA, 5, groupB, 5)
yazdır("t-istatistiği: " + t)

// Effect size
değişken d = stats_cohens_d(groupA, 5, groupB, 5)
yazdır("Cohen's d: " + d)

eğer (math_mutlak(t) > 2.306) ise yap  // α=0.05, df=8
    yazdır("Versiyon B anlamlı derecede daha iyi!")
son

Örnek 2: Veri Kalite Kontrolü

kullan stats

fonksiyon quality_check(data: [ondalık], n: tam_sayı): hiçbir yap
    // Tanımlayıcı istatistikler
    değişken mean = stats_ortalama(data, n)
    değişken std = stats_standart_sapma(data, n)
    değişken median = stats_medyan(data, n)
    
    yazdır("Ortalama: " + mean)
    yazdır("Std Dev: " + std)
    yazdır("Medyan: " + median)
    
    // Dağılım özellikleri
    değişken skew = stats_skewness(data, n)
    değişken kurt = stats_kurtosis(data, n)
    
    eğer (math_mutlak(skew) > 1.0) ise yap
        yazdır("UYARI: Yüksek çarpıklık tespit edildi!")
    son
    
    // Outlier tespiti
    değişken outlier_count = 0
    değişken i = 0
    iken (i < n) yap
        eğer (stats_is_outlier(data[i], data, n, 1.5)) ise yap
            outlier_count = outlier_count + 1
        son
        i = i + 1
    son
    
    eğer (outlier_count > 0) ise yap
        yazdır("Outlier sayısı: " + outlier_count)
    son
son

Örnek 3: Regresyon Analizi

kullan stats
kullan fmt

fonksiyon regression_analysis(X: [ondalık], y: [ondalık], n: tam_sayı): hiçbir yap
    // Regresyon modelini fit et
    değişken (a, b, r2) = stats_linear_regression(X, y, n)
    
    yazdır("\n=== REGRESYON ANALİZİ ===")
    yazdır("Model: y = " + fmt_float_precision(a, 3) + " + " + 
           fmt_float_precision(b, 3) + "x")
    yazdır("R² = " + fmt_percent(r2))
    
    // Model kalitesi
    eğer (r2 > 0.9) ise yap
        yazdır("Model kalitesi: MÜKEMMELyazdır("Model kalitesi: ORTA")
    son
    
    // Tahminler ve residual'lar
    değişken residuals = yeni_dizi(n)
    değişken i = 0
    iken (i < n) yap
        değişken y_pred = stats_predict_linear(X[i], a, b)
        residuals[i] = y[i] - y_pred
        i = i + 1
    son
    
    // Residual analizi
    değişken residual_mean = stats_ortalama(residuals, n)
    eğer (math_mutlak(residual_mean) > 0.1) ise yap
        yazdır("UYARI: Residual ortalaması sıfırdan farklı!")
    son
son

🔗 İlgili Modüller

• math - Matematik fonksiyonları
• linalg - Matris işlemleri
• random - Rastgele sayı üretimi

📖 Daha Fazla Bilgi

• Julia Statistics
• SciPy.stats
• R Statistical Functions

optim - Optimizasyon Algoritmaları

Modül: optim.berk (26.6 KB)
Kategori: Bilimsel Hesaplama
Inspiration: SciPy.optimize, Julia Optim.jl, Numerical Recipes

📋 Genel Bakış

optim modülü, sayısal optimizasyon problemleri için kapsamlı algoritmalar sunar. Makine öğrenmesi, mühendislik optimizasyonu ve bilimsel hesaplama için tasarlanmıştır.

Özellikler:

• ✅ Kök bulma (root finding)
• ✅ Tek değişkenli optimizasyon (line search)
• ✅ Gradyan tabanlı metotlar (gradient descent, BFGS)
• ✅ Gradyan gerektirmeyen metotlar (Nelder-Mead, Powell)
• ✅ Kısıtlı optimizasyon (penalty methods)
• ✅ En küçük kareler (least squares)
• ✅ Metaheuristik algoritmalar (simulated annealing, genetic algorithms)

🎯 Hızlı Başlangıç

Kök Bulma

kullan optim

// f(x) = x² - 4 = 0 denkleminin kökünü bul
fonksiyon f(x: ondalık): ondalık yap
    dön x * x - 4.0
son

// Bisection metodu
değişken kök = optim_bisection(f, 0.0, 3.0, 0.001, 100)
yazdır("Kök: " + kök)  // ≈ 2.0

// Newton-Raphson (türev gerekli)
fonksiyon df(x: ondalık): ondalık yap
    dön 2.0 * x
son

değişken kök2 = optim_newton_raphson(f, df, 1.0, 0.001, 100)

Tek Değişkenli Minimum

// f(x) = x² - 4x + 4 fonksiyonunun minimumunu bul
fonksiyon parabola(x: ondalık): ondalık yap
    dön x * x - 4.0 * x + 4.0
son

// Golden section search
değişken min = optim_golden_section(parabola, 0.0, 5.0, 0.001)
yazdır("Minimum: x = " + min)  // ≈ 2.0

Gradient Descent

kullan optim
kullan linalg

// f(x,y) = x² + y² fonksiyonunun minimumunu bul
fonksiyon gradyan(pos: [ondalık], n: tam_sayı): [ondalık] yap
    dön [2.0 * pos[0], 2.0 * pos[1]]
son

değişken başlangıç = [5.0, 3.0]
değişken minimum = optim_gradient_descent(gradyan, başlangıç, 2, 0.1, 100, 0.001)
yazdır("Minimum: (" + minimum[0] + ", " + minimum[1] + ")")  // ≈ (0, 0)

📚 API Kategorileri

1. Kök Bulma (Root Finding)

• optim_bisection - İkiye bölme metodu
• optim_newton_raphson - Newton-Raphson metodu
• optim_secant - Secant metodu
• optim_fixed_point - Sabit nokta iterasyonu

2. Line Search (Tek Değişkenli)

• optim_golden_section - Altın oran araması
• optim_brent - Brent metodu
• optim_armijo_line_search - Armijo koşulu

3. Gradient-Based Optimization

• optim_gradient_descent - Temel gradyan inişi
• optim_gradient_descent_momentum - Momentum ile GD
• optim_adam - Adam optimizer
• optim_bfgs_simple - BFGS quasi-Newton

4. Gradient-Free Optimization

• optim_nelder_mead_2d - Nelder-Mead simplex
• optim_coordinate_descent - Koordinat inişi

5. Constrained Optimization

• optim_penalty_method - Penalty metodu
• optim_augmented_lagrangian - Augmented Lagrangian
• optim_gradient_projection - Gradient projection

6. Least Squares

• optim_least_squares - Doğrusal en küçük kareler
• optim_gauss_newton - Gauss-Newton metodu
• optim_levenberg_marquardt - LM algoritması

7. Metaheuristics

• optim_simulated_annealing - Benzetilmiş tavlama
• optim_genetic_algorithm_1d - Genetik algoritma

8. Utilities

• optim_numerical_gradient - Sayısal gradyan
• optim_numerical_hessian - Sayısal Hessian

🔬 Detaylı Örnekler

Örnek 1: Makine Öğrenmesi - Logistic Regression

kullan optim

// Logistic loss için gradient
fonksiyon logistic_gradient(w: [ondalık], X: [ondalık], y: [ondalık], n: tam_sayı): [ondalık] yap
    // Gradient hesaplama
    // ∇L = X^T (σ(Xw) - y)
    // Basitleştirilmiş implementasyon
    dön grad
son

// Adam optimizer ile optimize et
değişken w_init = [0.0, 0.0]
değişken w_opt = optim_adam(logistic_gradient, w_init, 2, 0.01, 0.9, 0.999, 1e-8, 1000)

Örnek 2: Mühendislik - Yapısal Optimizasyon

// Kiriş optimizasyonu: minimum ağırlık, maksimum dayanım
fonksiyon beam_cost(dimensions: [ondalık], n: tam_sayı): ondalık yap
    değişken width = dimensions[0]
    değişken height = dimensions[1]
    
    // Maliyet = malzeme × alan
    değişken cost = width * height
    
    // Kısıt: moment of inertia > I_min
    değişken I = (width * height * height * height) / 12.0
    değişken penalty = 0.0
    eğer (I < 1000.0) ise yap
        penalty = 1000.0 * (1000.0 - I)
    son
    
    dön cost + penalty
son

değişken initial = [10.0, 20.0]
değişken optimal = optim_simulated_annealing(beam_cost, initial, 2, 100.0, 0.95, 1000, 42)

Örnek 3: Eğri Uydurma (Curve Fitting)

// y = a*exp(-b*x) + c modeline fit et
fonksiyon exponential_model(params: [ondalık], x: ondalık): ondalık yap
    değişken a = params[0]
    değişken b = params[1]
    değişken c = params[2]
    dön a * math_exp(-b * x) + c
son

fonksiyon residual(params: [ondalık], X: [ondalık], y: [ondalık], n: tam_sayı): [ondalık] yap
    değişken r = yeni_dizi(n)
    değişken i = 0
    iken (i < n) yap
        r[i] = y[i] - exponential_model(params, X[i])
        i = i + 1
    son
    dön r
son

// Levenberg-Marquardt ile optimize et
değişken initial_guess = [1.0, 0.1, 0.0]
değişken fitted = optim_levenberg_marquardt(residual, jacobian, initial_guess, 3, n_data, 0.01, 100)

⚡ Algoritmalar ve Kompleksiteler

Notlar:

• n: Boyut
• k: İterasyon sayısı
• ε: Tolerans
• T: Sıcaklık programı

🎓 Optimizasyon Stratejileri

Problem Türüne Göre Algoritma Seçimi

1. Smooth, Convex Problem:

   • Gradyan var mı? → BFGS veya Gradient Descent
   • Hessian var mı? → Newton metodu

2. Non-smooth, Non-convex:

   • Simulated Annealing
   • Genetic Algorithm

3. Kısıtlı Problem:

   • Penalty Method
   • Augmented Lagrangian

4. Büyük Ölçekli Problem:

   • Stochastic Gradient Descent
   • Coordinate Descent

5. Least Squares:

   • Gauss-Newton
   • Levenberg-Marquardt

🔗 İlgili Modüller

• linalg - Matris işlemleri
• stats - İstatistiksel optimizasyon
• math - Matematik fonksiyonları

📖 Daha Fazla Bilgi

• SciPy.optimize
• Julia Optim.jl
• Numerical Recipes
• Convex Optimization - Boyd & Vandenberghe

İleri okuma: Makine Öğrenmesi örnekleri

Anahtar Kelimeler

BERK dilinde kullanılan anahtar kelimeler (Türkçe/İngilizce):

Kontrol Yapıları

eğer/if, değilse/else, iken/while, için/for, kır/break, devam/continue

Fonksiyonlar

fonksiyon/function, yap/do, son/end, dön/return

Değişkenler

değişken/var, sabit/const

Modüller

içe_aktar/import, kullan/use

Operatör Önceliği

BERK operatörlerinin öncelik sıralaması (yüksekten düşüğe):

1. Parantez: (), []
2. Üst: **
3. Tekli: -, !
4. Çarpma/Bölme: *, /, %
5. Toplama/Çıkarma: +, -
6. Karşılaştırma: <, >, <=, >=
7. Eşitlik: ==, !=
8. Mantıksal AND: &&
9. Mantıksal OR: ||
10. Atama: =, +=, -=

Standart Kütüphane

BERK Standard Library: 75 modül (42 stdlib + 33 HAL), 4100+ fonksiyon

Temel Modüller

io, string, collections, result, time, fs, thread, sys

Bilimsel Hesaplama

math, physics, complex, random, linalg, statistics, plot

Ağ ve Veri

network, http, json, xml, csv, sqlite, crypto

Gömülü Sistemler (HAL)

33 HAL modülü (GPIO, SPI, I2C, UART, ADC, PWM, Timer...)

Hata Mesajları

BERK derleyicisinin ürettiği hata mesajları ve çözümleri:

Syntax Hataları

E001: Unexpected token - Beklenmeyen sembol
E002: Missing semicolon - Noktalı virgül eksik

Tip Hataları

E101: Type mismatch - Tip uyuşmazlığı
E102: Undefined variable - Tanımsız değişken

Bellek Hataları

E201: Null pointer - Boş pointer erişimi
E202: Out of bounds - Dizi sınırı aşımı

Geliştirme Ortamı Kurulumu

BERK geliştirme ortamı kurulum adımları:

Gereksinimler

• Windows 10/11 (64-bit)
• LLVM 17.0.6+
• Visual Studio Build Tools (opsiyonel)

Kurulum

1. BERK-lang.exe dosyasını indirin
2. PATH'e ekleyin: setx PATH "%PATH%;C:\berk\bin"
3. VS Code Extension'u yükleyin (v0.4.0)
4. berk --version komutuyla test edin

Kod Katkısı Nasıl Yapılır

BERK projesine kod katkısı yapmak için:

1. Fork: GitHub'da repository'yi fork edin
2. Clone: git clone https://github.com/YOUR_USERNAME/berk.git
3. Branch: git checkout -b feature/my-feature
4. Code: Değişikliklerinizi yapın, test edin
5. Commit: git commit -m "feat: add new feature"
6. Push: git push origin feature/my-feature
7. Pull Request: GitHub'da PR açın

Kodlama Standartları

Rust kodları için rustfmt kullanın, testler ekleyin, dokümantasyon yazın.

Dokümantasyon Katkısı

Dokümantasyon geliştirmek için:

Yapı

• mdBook formatında Markdown dosyaları
• berk-lang/book/src/ dizini
• Türkçe ve İngilizce sürümler

Kılavuz

1. Markdown dosyasını düzenleyin
2. mdbook build ile HTML oluşturun
3. Değişiklikleri kontrol edin
4. Pull request açın

Standartlar

Açık ve anlaşılır dil, örnekler ekleyin, kod bloklarini test edin.

Sık Sorulan Sorular

Genel Sorular

BERK nedir?

BERK, modern, güvenli ve performanslı bir programlama dilidir. İki dilli syntax desteğiyle hem Türkçe hem İngilizce anahtar kelimeler kullanabilirsiniz. LLVM backend kullanarak native kod üretir.

Neden BERK kullanmalıyım?

• İki Dilli Syntax: Türkçe veya İngilizce anahtar kelimeler, dilediğinizi kullanın
• Bellek Güvenliği: Modern tip sistemi ve hata yönetimi
• Yüksek Performans: LLVM ile native kod, sıfır maliyet abstraksiyonlar
• Zengin Stdlib: 18 modül, 600+ fonksiyon, bilimsel hesaplama desteği
• Kolay Öğrenme: Temiz syntax, anlaşılır hata mesajları

BERK hangi platformlarda çalışır?

Şu anda Windows x64 için derleyici mevcuttur. Linux ve macOS desteği yol haritasında bulunmaktadır.

BERK açık kaynak mı?

Evet, BERK MIT lisansı altında açık kaynak bir projedir. GitHub'da geliştirme yapılmaktadır.

Syntax ve Dil Özellikleri

İki dilli syntax nasıl çalışır?

BERK'te aynı programı iki farklı şekilde yazabilirsiniz:

// Türkçe
işlev merhaba() {
    yazdır("Merhaba Dünya!")
}

// İngilizce
function hello() {
    print("Hello World!")
}

Her iki style de aynı bytecode'a derlenir. Hatta aynı dosyada karıştırarak kullanabilirsiniz!

Hangi programlama paradigmalarını destekler?

• İmperatif Programlama: Klasik prosedürel kod
• Fonksiyonel Programlama: İteratörler, higher-order fonksiyonlar, immutability
• Yapısal Programlama: Struct'lar, modüler mimari
• Tip Güvenliği: Statik tip kontrolü, generic'ler (yol haritasında)

Garbage Collector var mı?

Hayır, BERK manuel bellek yönetimi kullanır (şu an için). Gelecekte Rust benzeri ownership sistemi veya optional GC planlanmaktadır.

Standart Kütüphane

Stdlib neler içerir?

BERK v1.4 stdlib 18 modül içerir:

Temel Modüller: io, string, collections, result, time
Sistem: fs, thread, sys, terminal
Fonksiyonel: iter, fmt
Bilimsel: math, physics, complex, random, linalg, stats, optim

Toplam 600+ fonksiyon ve 285 KB kod.

NumPy/SciPy benzeri özellikler var mı?

Evet! v1.4 ile birlikte bilimsel hesaplama modülleri eklendi:

• linalg: Matrix işlemleri, LU/QR/Cholesky, eigenvalue
• stats: İstatistik, regresyon, hipotez testleri, dağılımlar
• optim: Optimizasyon algoritmaları, gradient descent, BFGS

C/C++ kütüphanelerini kullanabilir miyim?

Şu anda doğrudan FFI (Foreign Function Interface) desteği yoktur. v0.9'da C kütüphane entegrasyonu planlanmaktadır.

Performance ve Optimizasyon

BERK ne kadar hızlı?

LLVM backend sayesinde C/C++ ile karşılaştırılabilir performans sunar. Benchmark'lar geliştirme aşamasındadır.

Optimizasyon seviyeleri nelerdir?

berk build -O0  # Optimizasyon yok (hızlı derleme)
berk build -O1  # Temel optimizasyonlar
berk build -O2  # Varsayılan (균衡)
berk build -O3  # Agresif optimizasyon

Paralel programlama destekleniyor mu?

Evet, thread modülü ile multi-threading yapabilirsiniz:

import thread

işlev işçi(id: Sayı) {
    yazdır("Thread ", id, " çalışıyor")
}

işlev ana() {
    değişken t1 = thread.spawn(işçi, 1)
    değişken t2 = thread.spawn(işçi, 2)
    
    thread.join(t1)
    thread.join(t2)
}

Araçlar ve Ekosistem

IDE/Editor desteği var mı?

VS Code için resmi extension mevcuttur:

• Syntax highlighting
• Code completion
• Error diagnostics
• Snippet'ler

Package manager var mı?

Henüz yok. v0.9'da berk-pkg package manager'ı planlanmaktadır.

REPL (Interactive shell) var mı?

Evet! berk repl komutuyla etkileşimli kabuğu başlatabilirsiniz:

berk repl
>>> değişken x = 10
>>> yazdır(x * 2)
20

Katkıda Bulunma

Nasıl katkıda bulunabilirim?

1. Kod: GitHub'dan projeyi fork'layın, feature branch açın, PR gönderin
2. Dokümantasyon: Typo düzeltmeleri, yeni örnekler, çeviri iyileştirmeleri
3. Test: Bug raporları, test case'leri, benchmark'lar
4. Stdlib: Yeni modüller, fonksiyonlar, algoritma iyileştirmeleri

Hangi teknolojileri bilmem gerekir?

• Rust: Derleyici Rust ile yazılmıştır
• LLVM: Backend için LLVM IR bilgisi faydalıdır
• Parsers: Lexer/Parser geliştirme deneyimi

İletişim kanalları nelerdir?

• GitHub Issues: Bug report ve feature request
• Discussions: Genel tartışmalar, sorular
• Discord: Gerçek zamanlı sohbet (yakında)

Karşılaştırmalar

Rust vs BERK?

BERK, Rust'tan ilham alır ama daha kolay öğrenilebilir bir alternatif hedefler.

Python vs BERK?

BERK, Python'un ifade gücünü, C'nin performansıyla birleştirir.

Sorun Giderme

"Tanımlanmamış referans" hatası alıyorum

Modülü import etmeyi unutmuş olabilirsiniz:

import math  // math modülünü ekleyin

işlev ana() {
    değişken x = math.sqrt(16)  // Artık çalışır
}

Derleme çok uzun sürüyor

-O0 ile hızlı derleme yapabilirsiniz:

berk build -O0 program.berk

"Stack overflow" hatası

Recursive fonksiyonlarda tail-call optimization kullanın veya iteratif versiyona geçin.

Sorunuz burada yok mu? GitHub Discussions'da sorun!

Yol Haritası

BERK programlama dilinin gelecek sürümleri için planlanan özellikler ve iyileştirmeler.

v0.9.0 - Runtime & Optimizasyon (Q2 2024)

Runtime Entegrasyonu

• BLAS/LAPACK bağlamaları (linalg performans artışı)
• GPU compute desteği (CUDA/OpenCL ön çalışma)
• JIT compiler (hot-path optimizasyonu)
• Better memory allocator (jemalloc/mimalloc)

Compiler İyileştirmeleri

• Dead code elimination
• Constant folding
• Loop unrolling
• Inline expansion
• Link-time optimization (LTO)

Debugging

• DWARF debug info üretimi
• GDB/LLDB entegrasyonu
• Breakpoint desteği
• Variable inspection

v1.0.0 - Stable Release (Q3 2024)

Language Features

• Generic types ve fonksiyonlar
• Trait/Interface sistemi
• Async/await (asenkron programlama)
• Pattern matching genişletmeleri
• Macro sistemi

Standard Library v2.0

• network: TCP/UDP socket'ler, HTTP client/server
• json: JSON parser ve serializer
• regex: Regular expression engine
• crypto: Hash, encryption, TLS
• db: SQLite, PostgreSQL bağlamaları

Package Manager

• berk-pkg: Paket yöneticisi
• Central package registry
• Dependency resolution
• Lock file (reproducible builds)
• Private registry support

Cross-Platform

• Linux x64 support
• macOS ARM64 (Apple Silicon)
• Cross-compilation toolchain

v1.5.0 - Advanced Features (Q4 2024)

Ownership & Lifetimes

• Rust-style ownership sistemi
• Borrow checker
• Lifetime annotations
• Zero-cost abstractions

Scientific Computing v2.0

• tensor: Multi-dimensional arrays, broadcasting
• dataframe: Pandas-like data manipulation
• plot: Visualization (matplotlib-like API)
• ml: Machine learning primitives
• numerical: ODE/PDE solvers

Concurrency

• Actor model (Erlang-style)
• Channel-based communication
• Work-stealing scheduler
• Lock-free data structures

v2.0.0 - Enterprise (2025)

Production-Ready

• Formal language specification
• Memory safety guarantees
• Certified compiler
• Long-term support (LTS)

Tooling

• Language Server Protocol (LSP)
• IntelliJ IDEA plugin
• Code formatter (berk fmt)
• Linter (berk lint)
• Documentation generator (berk doc)
• Testing framework (berk test)
• Benchmarking suite (berk bench)

Ecosystem

• Web framework (Express.js/Flask benzeri)
• GUI framework (native widgets)
• Game engine bindings (Godot/Unreal)
• Mobile support (Android/iOS)

Uzun Vadeli Hedefler

Performance

• WebAssembly compilation target
• RISC-V architecture support
• Embedded systems (bare-metal)
• Real-time systems (RTOS)

Language Evolution

• Effect system (algebraic effects)
• Dependent types (experimental)
• Gradual typing (opt-in dynamic)
• Metaprogramming (compile-time execution)

Community

• 1000+ GitHub stars
• 100+ contributors
• 500+ packages in registry
• Official certification program

Katkıda Bulunun

Bu roadmap topluluk geri bildirimleriyle şekillenmektedir. Öncelik değişiklikleri ve yeni özellikler için:

• Feature Request: GitHub Issues
• Discussions: GitHub Discussions
• RFC: Büyük değişiklikler için RFC (Request for Comments) açın

Öncelik Kriterleri

1. High Priority: Dil stabilitesi, güvenlik, performans
2. Medium Priority: Developer experience, tooling, stdlib
3. Low Priority: Experimental features, niche use-cases

Versiyon Politikası

• Major (x.0.0): Breaking changes, büyük özellikler
• Minor (0.x.0): Yeni özellikler, backward compatible
• Patch (0.0.x): Bug fixes, iyileştirmeler

Not: Tarihler tahminidir ve değişebilir. Aktif geliştirme durumu için GitHub Projects'e bakın.

Changelog

v0.8.0 - Standard Library v1.4 "Scientific Computing" (18 Kasım 2025)

🎉 Major Updates

Standart Kütüphane v1.4 - Bilimsel Hesaplama Desteği

Üniversite ve araştırma seviyesinde matematik kütüphaneleri eklendi!

Yeni Modüller (3 adet, 76.5 KB):

1. linalg.berk (25.4 KB) - Doğrusal Cebir
2. stats.berk (24.5 KB) - İstatistik ve Olasılık
3. optim.berk (26.6 KB) - Optimizasyon Algoritmaları

Geliştirilmiş Modüller:

• iter.berk (9.2 KB → 19.7 KB, +10.5 KB)
• fmt.berk (9.1 KB → 17.9 KB, +8.8 KB)

📊 Stdlib İstatistikleri

• 18 modül (+3 yeni)
• 285.9 KB toplam
• 600+ fonksiyon

Detaylar: Stdlib Dokümantasyonu