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 alan | Kural |
|---|---|---|
| 1 | Bellek | scope kapanır → bellek iade edilir |
| 2 | State | state'in ayrı hayatı yok; scope'ta yaşar |
| 3 | Eşzamanlılık | ayrı scope → paylaşılan durum yok → yarış oluşamaz |
| 4 | Kaynak / yıkım sırası | yıkım = oluşumun tersi; elle temizlik yok |
| 5 | Arayüz ağacı | widget ağacı = scope ağacı; buton bir scope'un görünen yüzü |
| 6 | Freeze / askıya alma | dal 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.
# 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:
| Tip | Alt Yapı | Kapsam |
|---|---|---|
numeric | ham i64 — tek CPU komutu | 18 basamağa kadar; import bigdecimal ile sınırsız + ondalık |
string | handle — inline veya heap | Herhangi bir uzunlukta metin; birleştirme & |
boolean | — | doğru / yanlış |
Klasik dillerde programcı “bu değişkene int8 mi, int64 mi,
float mı double 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:
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:
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.
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.
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.