MELP Ne Yapabilir?

Dil tasarımından binary güvenliğine — temel özellikler.

Bu sayfadaki her iddia bir kanıt damgası taşır: çalışıyor  ·  🔬 kısmî / altyapı var  ·  ⏸️ tasarım niyeti, ölçülü olgu DEĞİL. Dürüstlük satırı olmayan iddia yayınlanmaz — bu bir çekince değil, ev kuralıdır.

🧭 1. Scope-Oriented Programming — Model 🔬 Kısmî

Scope, yaşam süresinin evrensel birimidir.

MELP'in temel soyutlaması scope'tur — tıpkı OOP'de object, FP'de function, Actor Model'de actor olduğu gibi. Ama iddia "scope kullanıyoruz" değil: scope'un tek birleştirici yaşam süresi soyutlaması olması. MELP, birleşik bir Scope-Oriented Programming modeli önerir; scope, belleği, kaynakları, eşzamanlılığı, state'i ve arayüzü yöneten birincil yaşam süresi soyutlamasıdır.

#Scope'un yönettiği alanKural
1Bellekscope kapanır → bellek iade edilir
2Statestate'in ayrı hayatı yok; scope'ta yaşar
3Eşzamanlılıkayrı scope → paylaşılan durum yok → yarış oluşamaz
4Kaynak / yıkım sırasıyıkım = oluşumun tersi; elle temizlik yok
5Arayüz ağacıwidget ağacı = scope ağacı; buton bir scope'un görünen yüzü
6Freeze / askıya almadal donar, durum korunur, kardeşler akar

Katmanlama — scope ≠ custody ≠ destroy. Scope üst düzey organizasyon ilkesidir; custody onun üzerinde çalışan belirli bir kaynak-ömrü modelidir; destroy o modelin yürütücüsüdür. Üçü aynı şey değildir. Bu ayrım iddiayı hem daraltır hem güçlendirir: "custody en iyi bellek modelidir" DENMEZ — custody ilk kanıtlanmış realization'dır, tek mümkün model değil. Custody başarısız olsa bile sonuç "Scope-Oriented Programming yanlış" değil, "bu realization yanlış" olur.

Dürüstlük satırı — akrabalar. Fikrin parçaları literatürde vardır. Hiçbiri tek başına yeni değil; ayrıştırıcı olan birleşim. RAII (C++) temizliği tipe bağlar, yalnız kaynağı kapsar; region-based memory (Tofte–Talpin) yalnız belleği; ownership/borrowing (Rust, Cyclone) bellek + kaynağı; structured concurrency (coroutineScope, StructuredTaskScope, Trio nursery) yalnız görev ömrünü; component tree (React, Flutter) yalnız UI + state'i — üstelik dilin değil çerçevenin kuralı olarak; süreç izolasyonu (Erlang/BEAM) bellek + eşzamanlılık + hatayı. MELP'in scope'u altısını birden hedefler.

Erlang şerhi: tek-birim modelinde yalnız değiliz — Erlang'ın birimi de tektir (süreç). Fark: Erlang'ın izolasyonu daha serttir (bellekler ayrı, duvar delinmez); MELP'in duvarını derleyici çizer ve external yazıldığı an garanti biter. Buna karşılık süreçle GUI ağacı ya da bellek custody'si kurulamaz. Farklı takaslar — biri diğerinden üstün değil.

Kanıt durumu: altı alandan ikisi ölçülü — bellek (4/4 doğrulanmış ölüm, sızıntı 0, runtime registry'sinden) ve eşzamanlılığın "veri yarışı inşa edilemez" kanadı (4 düşmanca program, yapısal ret). State, arayüz ve yıkım sırası mimaride çözülü ama uçtan uca kanıt panosu yok.

Özgünlük üzerine: lexical scope bilgisayar biliminde her yerde ve yukarıdaki her bileşenin öncülü var. MELP'in önerdiği şey birleşim — scope'un altı alanda birden tek yaşam süresi soyutlaması olması — ve bu birleşimin başka bir yerde adlandırılmış ya da tanımlanmış hâline rastlamadık. Yine de "ilk" demiyoruz: formal bir literatür taraması yapılmadı ve yapılana dek o kelime bu sitede geçmeyecek. İddia bu yüzden küçülmüyor — küçülen yalnızca cümle.

🛡️ 2. Memory Safe — GC'siz, Annotation'sız ✅ Çalışıyor

MELP'te her değer doğduğu scope'a aittir ve o scope kapanınca serbest bırakılır (custody). Bellek temizliği programcının değil, scope'un işidir — ne çalışma zamanı Garbage Collector'ı ne de Rust'ın borrow checker'ı gibi manuel bir işaretleme sistemi gerekir.

Dil Hız Memory Safety Ekstra Yük
C / C++ ❌ Manuel
Java / Python ❌ GC Garbage Collector
Rust Borrow checker annotation
MELP Hiçbiri — scope sınırı yeterli

Ömür = scope: Bir değişkenin yaşam süresi, içinde bulunduğu scope'un yaşam süresidir — ayrıca yönetilmesi gereken bağımsız bir "durum" katmanı yoktur. Uzun ömürlü veri gerektiğinde onu daha üst bir scope'ta tanımlarsınız; kural değişmez, yalnızca sahip değişir.

Dürüstlük satırı: Custody bugün büyük sayıları ve yazdırılan metinleri kapsar (valgrind ile kaçak 0). Genel metin geçicileri henüz custody dışındadır ve sızdırır — bilinen ve adreslenmiş bir sınırdır, birleşik custody çalışmasıyla kapanacaktır.

⚡ 3. LLVM Native Binary

MELP sözdizimsel bir deney değildir. Kaynak kod LLVM IR'e derlenir, ardından llc ve platform linker'ı aracılığıyla gerçek bir ELF binary üretilir. GC yok, interpreter yok, overhead yok.

Terminal
# LLVM IR görüntüle
bin/run_melp ornek.mlp --ir

# Native binary üret
melp_compiler ornek.mlp -o a.out

# Çalıştır — lli veya interpreter gerektirmez
./a.out

Üretilen binary, lli veya herhangi bir çalışma zamanı olmadan doğrudan işletim sistemi tarafından çalıştırılır. C/C++ ile karşılaştırılabilir performans hedefleri için LLVM optimizer geçişleri uygulanabilir.

🔀 4. Eşzamanlılık — Veri Yarışı İNŞA EDİLEMEZ ✅ / ⏸️

MELP'in eşzamanlılık cevabı, uzanıp aldığınız bir primitive değil; yarışı mümkün kılan koşulun yokluğudur. Scope sınırı izolasyon sınırıdır: child, parent'ının değişkenine yazamaz — dolayısıyla iki scope'un çekişeceği bir şey yoktur. Paylaşım yalnız üç kontrollü kapıdan geçer: tunnel (geçici velayet), peek (salt-okunur anlık) ve channel (mesaj kopyası). Mutasyon tek noktada olduğu için dilde mutex ya da atomic keyword'ü yoktur — koruyacakları bir şey yok.

✅ Ölçülü: bilerek düşmanca yazılmış dört program — her biri veri yarışı inşa etme girişimi — çalışma zamanında yakalanmak yerine yapısal olarak reddedildi. Başarısızlık dil düzeyinde, üste eklenmiş bir teşhis değil.

⏸️ Dürüstlük satırı — neyi İDDİA ETMİYORUZ. "İzolasyon = bedava paralellik lisansı" bir tasarım niyetidir, ölçülü olgu değildir. Henüz meşru kapı (arayüz/tunnel/channel) uygulanmadı ve runtime tek akış: MELP bugün scope'larınızı paralel koşturmaz. Ayrıca async, await, spawn, thread, coroutine, future ve callback yoktur — bunlar uygulanmayı bekleyen özellikler değil, bilinçli olarak reddedilmiş ithal kalıplardır. Erlang otuz yıldır doğru cevabı biliyor, ana akım hâlâ mutex kilitliyor; bizim yolumuz scope + channel + event-loop.

🔁 5. State Yönetimi Yoktur — Çünkü State'in Ayrı Hayatı Yoktur 🔬 Kısmî

Flutter state'i yönetir; MELP state'i yaşatır.

Flutter/React acısının kökü şudur: arayüz ağacı her kurulumda ölür-doğar, veri ise kalıcı olmalıdır — iki ömür birbiriyle savaşır. StatefulWidget, setState, Provider, hooks... hepsi bu uyuşmazlığı yönetme katmanıdır.

MELP uyuşmazlığı yönetmez, ortadan kaldırır: widget ağacı = scope ağacı, scope = ömür. Veri, doğduğu scope yaşadıkça yaşar. "State'i nereye koysam, yukarı mı taşısam" sorusu tanım gereği doğmaz — çünkü MELP'te ayrı yaşam döngüsüne sahip bir "state" kavramı yoktur.

Dürüstlük satırı: Değişkenler elbette vardır — iddia "veri yok" değil, "ayrı yaşam döngülü state kavramı ve onu yöneten katman yok"tur. En yakın akrabalar: Phoenix LiveView (süreç = state sahibi) ve Svelte (reaktivite katmanını derleyip yok etme ruhu). Farkımız: ömür birleştirmesi framework hilesi değil, dil kuralıdır. 🔬 Melpion masaüstünde çalışır; tunnel/channel kısmî, büyük uygulamada henüz kanıtlanmadı.

🧊 6. Freeze — Dondur, Öldürme 🔬 Kısmî

Yaşamın üç fiili vardır: yaşa, uyu, öl.

Her şey bir scope ise ve scope bir yaşam birimiyse, bunun kaçınılmaz bir sonucu vardır: çalışan herhangi bir dal, alt ağacıyla birlikte dışarıdan dondurulabilir. Durum tam olarak korunur — sayaçlar, zamanlayıcılar, bellekteki her şey. Sonra kaldığı yerden devam eder ya da temizlikle birlikte kapatılır. Dondurma seçicidir: kardeş scope'lar akmaya devam eder.

Bunun en somut karşılığı güvenlik olaylarında görülür. Bir sunucuya saldırı tespit ettiğinizde klasik seçenek acıdır: süreci öldürürsünüz, saldırı durur ama uçucu deliller (oturum anahtarları, enjekte edilmiş kod, bağlantı durumu) buhar olur. MELP'te o alt sistemi dondurursunuz:

SonuçNeden
Saldırı ilerleyemez Donmuş scope tek adım bile atamaz
Deliller korunur Süreç ölmediği için bellek olduğu gibi durur
Delil çevresi kesindir Scope tüm belleğine sahiptir (custody) — sınırları bellidir
Hizmet sürer Diğer bölgeler/kardeş scope'lar akmaya devam eder

Bugün çalışıyor: Canlı Demo sayfasındaki "seçici freeze" senaryosu bunu tarayıcıda gösterir — üç scope bağımsız çalışır, biri dondurulur, kardeşleri akmaya devam eder, uyandırıldığında kaldığı sayaçtan sürer. Tick değerleri WASM runtime'ından gelir, arayüzde saklanmaz. Canlı Demo'da gör →

Dürüstlük satırı: Doğru terim "güvenlik duvarı" değil, karantina: freeze trafiği filtrelemez, alt sistemi tümüyle durdurur. Bu bir uygulama düzeyi kontroldür, işletim sistemi düzeyinde bir güvenlik sınırı değildir. Kotlin'in suspend'i fonksiyon düzeyinde ve içeriden, Erlang'ın sys:suspend'i süreç düzeyindedir (en yakın akraba). 🔬 Bugün dışarıdan bir API ile çalışır; programın kendi içinden scope dondurması ve dil sözdizimine tam gömülmesi geliştirme aşamasındadır.

🔢 7. Tip Sistemi — 3 Tip, Sıfır Tip Derdi

MELP'te yalnızca üç değişken tipi vardır:

TipAlt YapıKapsam
numericham i64 — tek CPU komutu18 basamağa kadar; import bigdecimal ile sınırsız + ondalık
stringhandle — inline veya heapHerhangi bir uzunlukta metin; birleştirme &
booleandoğru / yanlış

Klasik dillerde programcı “bu değişkene int8 mi, int64 mi, floatdouble mı ayırmalıyım?” derdine düşer. MELP’te bu dert yoktur. Kullanıcının tek yaptığı ihtiyacını olan tipi tanımlamaktır:

MELP — Tip Tanımı
numeric kucuk   = 1
numeric buyuk   = 9999999999999
string  mesaj   = "Merhaba"
boolean aktif   = true

-- Ondalık ayraç virgüldür (argüman ayracı bu yüzden ";")
import bigdecimal
numeric pi      = 3,14159265358979323846
numeric tutar   = 19,99

İki dünya modeli: numeric varsayılan olarak ham i64'tür — tek CPU komutu, sıfır ek yük. Bir dosyada import bigdecimal yazıldığında o dosyada donanım taşma bayrağıyla otomatik büyük-sayı terfisi ve 3,14 ondalık desteği devreye girer: mantissa + ölçek olarak saklanır (kayan nokta değil), böylece 0,1 + 0,2 tam olarak 0,3 eder. İlke: kimse kullanmayacağı bir şeyin maliyetine katlanmaz.

Dürüstlük satırı: Varsayılan dünya (i64) kanıtlıdır ✅. import bigdecimal dünyası 🔬 — mekanizma çalışır, korpus kanıtı tamamlanmadan üretim için önerilmez. Varsayılan dünyada i64 taşması sessizce sarar; bu bilinçli bir bedeldir.

✔️ 8. OK Bir Değerdir — Hata Scope İçinde Hallolur

MELP'te void diye bir tip yoktur. "Bir şey döndürmeyen" fonksiyonlar aslında OK döndürür — başarı anlamına gelen ve ABI'de i64 taşınan gerçek bir değer. OK'i LLVM void'ine eşlemek bir codegen hatasıdır; bir zamanlar gerçek bir hataydı da — çıkış kodu bozulması bug'ının kökü buydu.

Hata da aynı mantıkla ele alınır: bir hata doğduğu scope içinde çözülür, dışarı taşmaz. Taşıması gerekiyorsa bunu açıkça işaretlersiniz? operatörü "bu çağrı başarısız olursa hatayı yukarı ilet" demektir. Görünmez bir istisna zinciri yoktur; hata yayılımı kodun kendisinde okunur.

Dürüstlük satırı — bir düzeltmeyle birlikte. Bu sayfa daha önce main'in sonuna return 0 töreni yazılmadığını söylüyordu; bugünkü derleyici için bu YANLIŞTI. Kanonik giriş noktası numeric function main() + açık return 0'dır — derlenen budur ve derleyicinin KENDİ kaynağı bunu kullanır. OK function main() koda inmemiş bir tasarım niyetiydi. "void yok, OK bir değerdir" felsefesi diğer tüm fonksiyonlar için geçerlidir; istisna yalnız main'dir.

? operatörü Rust'takinden esinlenmiştir; farkımız OK'in tip değil değer olması ve hatanın scope yaşam döngüsüne bağlanmasıdır. Bugün kullanılan hata yakalama yapısı expect bloğudur; Result tipi ve ? yayılımı 🔬 deneyseldir.

☕ 9. Yığın ve Kuyruk Yoktur — Çünkü Dokudadır 🔬 Kısmî

MELP'te yerleşik Stack veya Queue veri yapısı yoktur — ve gerekmez, çünkü ikisi de dilin dokusunda zaten vardır.

LIFO, scope'un yaşam düzenidir. Scope'lar açıldıklarının tersi sırayla kapanır; yıkım sırası oluşturmanın tersidir. Programcı yığın yönetmez — scope açar ve kapatır. Bunun bir yan sonucu daha var: mutasyon tek bir scope'ta ve sıralı olduğu için, dilde mutex ya da atomic gibi bir anahtar kelime bulunmaz.

FIFO, channel'ın teslim düzenidir — sloganıyla: kahve soğumayacak. İşi biten scope'un kuyruğu önce boşalır; hazır sipariş sıcakken servis edilir, hiçbir mesaj sonraki işler sürerken tezgâhta beklemez.

Dürüstlük satırı: Her dil çağrı yığınına dayanır (LIFO altta hep vardır) ve Go'nun channel'ları da FIFO'dur. MELP'in iddiası bunları ayrıca bir veri yapısı ya da eşzamanlılık ilkesi olarak sunmaya gerek bırakmayan tek model olmasıdır. 🔬 channel/tunnel uygulaması kısmîdir; algoritmik yığın/kuyruk ihtiyacı bugün liste üzerine elle kurulur — bu bilinen bir boşluktur.

🐛 10. debug Bloğu — Geçmişten Geleceğe Mektup

Yorum satırı okunmayabilir. Mektup koşar.

Kurumsal hafızanın en sessiz kaybı şudur: kod kalır, niyet ölür. Sistemi yazan mimar emekli olur; ardında bıraktığı yorum satırlarını kimse okumaz. Daha kötüsü, o yorumlar zamanla yalan olur — "üye sayısı 10 bini geçmez" diye yazılmıştır, doğrudur, sonra dünya değişir ve program sessizce yanlışlaşır.

MELP'te varsayımı koşan bir nöbetçiye çevirirsiniz:

MELP — debug bloğu
debug
    if uye_sayisi > 10000 then stop
    -- Üye sayısı 10 bini geçince yeni bir veritabanı
    -- mimarisi gerekebilir. — 2026, ilk ekip
end debug

On yıl sonra, o mimar çoktan ayrılmışken, üye sayısı 10 bini geçtiği gün program durur ve mektubu okutur. Varsayım sessizce eskimez.

Üretimde sıfır maliyet: MELP_RELEASE=1 ile derlendiğinde debug blokları tamamen çıkarılır — üretim binary'inde tek iz kalmaz. Bugün hata ayıklayıcıda (gdb/lldb) her blokta durulabiliyor.

Dürüstlük satırı: En yakın akrabaları JavaScript'in debugger; ifadesi, C'nin assert'ü ve Eiffel'in sözleşmeli tasarımıdır. MELP'inki blok formu + koşul + açıklamayı birleştirmesiyle ayrışır: assert ihlalde çöker, MELP'in stop'u ise scope'u dondurmayı hedefler — durum korunur, kardeş işler akmaya devam eder. Bu dondurma entegrasyonu henüz tasarım aşamasındadır.

Açık dil kararı, açıkça: release'te strip etmek, bu özelliği en değerli kılan senaryolarla gerilimde — mektup tam gerektiği yerde silinmemeli. Tasarım bu yüzden seviyeli bloklara doğru gidiyor: bugünkü gibi strip edilen debug'ın yanında, üretime kadar yaşayan bir debug keep — böylece kritik nöbetçi, ona en çok ihtiyaç duyulan ortamda da koşabilir; maliyeti tek karşılaştırma. Alternatif olarak release-strip'i opt-in yapmak değerlendiriliyor. Karar, çevre birimleri fazından sonraki ilk dil oturumunun gündeminde; hükmü değil adayları yazıyoruz, çünkü hüküm henüz ölçülmedi.

💀 11. Ölü Modül Felsefesi

Scope modelinin doğal sonucu: modüller varsayılan olarak ölüdür. Hiçbir modül kendi başına kaynak tahsis etmez ya da bellekte yer kaplamaz. Bir modülü kullanan scope diriltir; o scope kapanınca modül de ölür — atıl kaynak sıfır, çöp toplayıcıya gerek yoktur.

Sonuç: Bellek temizliği programcının değil, scope'un işidir — GC veya borrow checker olmadan. Her değer doğduğu scope'a aittir (custody); scope kapanınca topluca serbest bırakılır, return ile dönen değerin velayeti çağırana devredilir.

Dürüstlük satırı: Custody bugün büyük sayıları ve yazdırılan metinleri kapsar — bu cephe valgrind ile kanıtlıdır (kaçak 0). Genel metin geçicileri henüz custody dışındadır ve sızdırır; bu bilinen ve adreslenmiş bir sınırdır — birleşik custody çalışmasıyla kapanacaktır. "Programcı bellek yönetmez" iddiası bugün bu kapsamla doğrudur.

📌 12. Adlandırılmış Kapsamlar — scope

scope ad ile iç içe bloktan temiz koşullu çıkış sağlanır. Derin döngülerde bayrak değişkeni ya da exception gerekmez.

MELP — Scope
scope islem
    loop each i in satirlar
        loop each j in sutunlar
            if bul(i; j) then
                exit islem  -- iç içe döngüden temiz çıkış
            end if
        end loop
    end loop
end scope

🎨 13. Arayüz Bir Çizimdir — GUI = Scope Ağacı 🔬 Kısmî

Çoğu dilde arayüz ayrı bir dille yazılır: XML, QML, HTML, JSX. MELP'te arayüz dilin kendi scope'larıyla tanımlanır — çünkü ikisi yapısal olarak aynı şeydir. <a><b/></a> ile scope a … end a arasındaki eşleme birebirdir: eleman = scope, iç içelik = sahiplik, kapanış etiketi = isim yankısı, id = scope adı, attribute = özellik.

Bunun pratik sonucu şu: arayüzünüzü çizerek tasarlarsınız. Bir tasarım aracında (Figma vb.) çizip SVG olarak dışa aktarırsınız; katman adları scope adlarına karşılık gelir, siz de davranışı MELP'te yazarsınız. Widget ağacı = scope ağacı olduğu için "çocuk ebeveyniyle birlikte ölür" kuralı arayüzde de aynen geçerlidir.

Bugün nerede: MELP editör eklentisinde bir SVG designer ve .svge formatı çalışıyor — widget'ları (label, textbox, combobox, checkbox, buton) tanıyor ve bunlara bağlı MELP olay işleyicisi iskeleti üretiyor.

Dürüstlük satırı: Çalışan kısım designer ve .svge → MELP iskelet üretimidir. "Çizimden tek tıkla çalışan uygulama" akışı henüz yoktur — üretilen iskeletin gövdesini bugün siz yazarsınız. Tarayıcıda SVG projeksiyon ve GUI'nin dil sözdizimine tam gömülmesi geliştirme aşamasındadır. En yakın akrabalar QML/SwiftUI/Flutter'dır; farkımız arayüzün ayrı bir DSL değil, dilin bellek ve yaşam modelinin doğal uzantısı olmasıdır.

🧱 14. Struct + Fonksiyon — Class Yok

MELP'te veri struct ile, davranış bağımsız fonksiyonlarla tanımlanır. OOP hiyerarşisi olmadan aynı modelleme gücü, çok daha az karmaşıklık.

MELP — Struct + Enum + Match
struct Nokta
    numeric x
    numeric y
end struct

enum Renk
    Kirmizi
    Yesil
    Mavi
end enum

Renk r = Renk.Mavi

match r
    case Renk.Kirmizi then println("kırmızı")
    case Renk.Mavi then println("mavi")
end match

🗂️ 15. Modüler Mimari

Her modül tek sorumluluğa sahiptir; merkezi orkestratör yasaktır. Derleme sırası otomatik dependency graph'tan belirlenir — döngüsel bağımlılık derleme zamanında hata olarak raporlanır.

Tasarım İlkesi: Modüller birbirinin değişkenlerine doğrudan yazamaz — scope sınırı izolasyon sınırıdır. Paylaşım yalnızca üç kontrollü kapıdan geçer: tunnel (geçici velayet), peek (salt-okunur kopya), channel (mesaj kopyası).

Dürüstlük satırı — tedarik zinciri, üç sınıfta. Bu madde derleyicinin kendi kaynağının nasıl örgütlendiğiyle ilgilidir, bağımlılık yönetimiyle değil. Tedarik zinciri riski üçe ayrılır ve MELP her birinde farklı yerde durur; üçünü tek bir hükme indirmek her iki yönde de dürüstsüzlük olur.

✅ Paket ekosistemi sınıfı (left-pad, log4shell, typosquatting): yapısal olarak yok. MELP'in üçüncü taraf paket ekosistemi bulunmuyor; geçişli bağımlılık ve üstüne binen risk oluşamaz.
❌ Build zinciri sınıfı (xz): tamamen açık, cevabımız yok. Her MELP binary'si LLVM/clang, libgmp, libc ve linker'ın üstünde duruyor. xz arka kapısı tam olarak bu sınıftı — bir paketin değil, build sürecinin ele geçirilmesi. Bugün bir önlemimiz yok.
🔬 Tohum (Thompson, Trusting Trust): yolu çizili, yürünmedi. Derleyici golden tohumdan inşa ediliyor. Tohum bir kez ele geçirilse arka kapı kendini yeniden üretir ve bit-bit N1=N2 kapımız yine yeşil yanar — kapı determinizmi kanıtlar, tohumun temizliğini değil. Buna karşı MELP'in yapısal bir avantajı var: ürettiği IR metindir, yani tohum kaynaklı bir enjeksiyon orada görünmek zorundadır — self-hosting dillerin çoğunda olmayan bir denetim noktası. Tohum rafı ve N-1 zinciri diverse double-compiling için hazır hammaddedir. İkisi de henüz işletilmiyor.

Kapalı kaynak bunu çözmez. MELP kapalı kaynaktır ve bunu bir tedarik zinciri cevabı gibi sunmak kolay — ve yanlış — olurdu. Değildir: bağımsız denetimi, reproducible-build doğrulamasını ve kullanıcının çalıştırdığı şeyi kendi kontrol etme imkânını kaldırdığı için doğrulanabilirliği yükseltmez, düşürür. Asıl ayrım şu: geliştiricinin sahip olduğu güven bilgisi ile kullanıcının bağımsız olarak doğrulayabildiği güven aynı şey değildir.

🌐 16. Platform Bağımsız 🔬 Kısmî

Bir kere yaz, her yerde çalıştır. LLVM altyapısı sayesinde aynı kaynak kod Linux, macOS ve Windows için native binary üretir. Çapraz derleme için ayrı araç gerekmez.

Mevcut durum: Linux x86-64 tam desteklenmektedir. macOS ve Windows desteği beta sürümüyle birlikte gelecektir.

🎯 17. Self-Hosting — Derleyici Kendini Derler

MELP derleyicisi MELP ile yazılmıştır ve kendi kaynağını derler. "Self-hosting" denen bu eşik, bir dilin olgunluk göstergesidir ve MELP'te bugün çalışmaktadır — C++ bootstrap dönemi geride kalmıştır.

Dahası bu, her değişiklikte zorunlu bir kapıdır: derleyici kendi kaynağını derler (N1), ürettiği derleyici aynı kaynağı yeniden derler (N2) ve iki çıktı bit bit özdeş olmak zorundadır. Fark varsa değişiklik geri alınır. Derleyici her gün kendini yeniden kanıtlar.

Kanıt zinciri: golden → N1 → N2 → N3, her adımda diff = 0 ve ardından bağımsız bir kullanıcı programının derlenip çalıştırılması. Bu zincir yeşil değilse hiçbir değişiklik kabul edilmez.

Dürüstlük satırı: Bootstrap testi her self-hosting dilde vardır; MELP'in farkı bunun her değişiklikte zorunlu kapı olmasıdır — istisnası yoktur.

📜 Kökenler — İsim Nereden Geliyor Tarihsel — bugünkü iddianın parçası DEĞİL

MELP hayata MLP · Multi Language Programming olarak başladı. Özgün fikir, program mantığının yazıldığı insan dilinden ve sözdizimi stilinden bağımsız olmasıydı: Türkçe, İngilizce, Rusça ya da Japonca kaynağı okuyan tek bir derleyici; yeni bir dil eklemek için derleyici koduna dokunmak yerine bir keywords.json dosyası yazmak; ve bunun yanında üç sözdizimi stili — doğal MELP, C-stili süslü parantez, Python-stili iki nokta — derleyici kodu görmeden önce tek biçimli bir iç temsile normalize ediliyordu.

Bu katman artık dil iddiasının parçası değildir. Ad kaldı; odak scope'a taşındı. MELP'in bugün önerdiği şey yukarıdaki §1'de yazılıdır: birincil yaşam süresi soyutlaması olarak scope. Kökeni buraya kaydediyoruz çünkü doğrudur ve ismi açıklar — sunulan bir özellik olduğu için değil.

Neden rafa kalktı: bir dil dikkati bir liste ile değil, tek bir fikirle kazanır. Çok dilli anahtar kelimeler bir normalizer özelliğiydi — gerçekti, ama MELP'i kullanmaya değer kılan şeyin kıyısında duruyordu ve dili asıl ayrıştıran şeyle ön sayfa için yarışıyordu. Dürüst konum bu sayfadaki konumdur: tek iddia, tam boyutunda, kanıt durumu işaretli.

Deneyin

Tüm bu özellikleri tarayıcıdan, kurulum yapmadan test edebilirsiniz.