docs: STRATEGY.md — как Bux ще победи Rust, Nim и C (gradual ownership)

docs/STRATEGY.md

@@ -0,0 +1,160 @@
+# Как Bux ще победи Rust, Nim и C
+
+> **Дата:** 2026-05-31 | **Версия:** 0.2.0 (bootstrap)
+
+---
+
+## Пазарна позиция
+
+Всеки език заема ниша. Bux влиза **между тях** с уникална философия:
+
+```
+Скорост на писане (бързо → бавно):
+  C  ████████████████████  (няма абстракции, но бързо става)
+  Nim ██████████████       (изразителен, GC)
+  Bux ████████████████     (изразителен, без GC)
+  Rust ████████            (borrow checker бави)
+
+Безопасност (ниска → висока):
+  C  ████                  (ръчна, pointer-и)
+  Nim ████████             (GC предпазва от leak, не от use-after-free)
+  Bux ████████████         (опционален borrow checker)
+  Rust ██████████████████  (пълен borrow checker)
+
+Производителност (бавно → бързо):
+  Nim ████████████         (GC добавя overhead)
+  Rust ██████████████████  (zero-cost abstractions)
+  C   ██████████████████  (близо до метала)
+  Bux ██████████████████  (C transpiler → native)
+```
+
+---
+
+## Уникалното предимство: Gradual Ownership
+
+**Никой друг език не предлага това.**
+
+| Модел | Език | Как работи |
+|-------|------|------------|
+| Всичко непроверено | C, Zig | Бързо писане, бъгове в runtime |
+| Всичко проверено | Rust | Бавно писане, безопасно в compile-time |
+| **Опционална проверка** | **Bux** | **Бързо писане, проверка само на критичния код** |
+
+### Синтаксис
+
+```bux
+// Режим 1: Без проверки (като C/Nim) — за бързо прототипиране
+func QuickHack(arr: *int, len: int) {
+    for i in 0..len {
+        arr[i] = arr[i] * 2;  // no bounds check, no borrow check
+    }
+}
+
+// Режим 2: С проверки (като Rust) — за critical paths
+@[Checked]
+func SafeMerge(a: &[int], b: &[int]) -> Vec<int> {
+    // borrow checker проверява че a и b не се припокриват
+    // bounds checking на всеки достъп
+    // lifetime tracking гарантира че резултатът не надживява входовете
+}
+```
+
+### Защо това печели
+
+| Програмист | Какво иска | Решение |
+|------------|------------|---------|
+| **C програмист** | "Не ми се занимава с borrow checker" | Пише без `@[Checked]`, получава C-скорост |
+| **Rust програмист** | "Искам гаранции за safety" | Добавя `@[Checked]` на критичните функции |
+| **Team lead** | "Искам баланс скорост/безопасност" | Prototype бързо, harden после |
+| **Startup** | "Трябва да shipping-нем вчера" | Без проверки за MVP, добавят се после |
+
+---
+
+## Вторични предимства
+
+### 2. Compile-time функции (CTFE)
+
+```bux
+// Nim има CTFE, Rust няма (само const fn с ограничения)
+const func Fib(n: int) -> int {
+    if n <= 1 { return n; }
+    return Fib(n-1) + Fib(n-2);
+}
+
+const FIB_40 = Fib(40);  // изчислява се при компилация
+```
+
+**Предимство:** Предварително изчислени таблици, парсъри, валидации на compile-time, които Rust не може.
+
+### 3. По-прост от Rust
+
+```bux
+// Rust: трябват lifetime annotations
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { ... }
+
+// Bux: без анотации в обикновен код
+func Longest(x: String, y: String) -> String { ... }
+// Само в @[Checked] зони се добавят при нужда
+```
+
+### 4. По-бърза компилация от Rust
+
+```
+Rust (LLVM):  10-60 секунди за среден проект
+Bux (C):      <1 секунда за среден проект (като Nim)
+```
+
+C backend → gcc/clang компилират C много по-бързо отколкото LLVM компилира Rust.
+
+### 5. Algebraic типове (Nim ги няма нативно)
+
+```bux
+// Bux: първокласни algebraic enums
+enum Result { Ok(int), Err(String) }
+let x = Ok(42);
+match x { Ok(v) => ..., Err(e) => ... }
+
+// Nim: трябват макроси или object variants
+```
+
+---
+
+## Пътна карта за победа
+
+| Фаза | Feature | Ефект |
+|------|---------|-------|
+| **8.1** | ✅ Error handling (`?`, `!`) | По-чисто от Nim |
+| **8.2** | ⏳ `@[Checked]` borrow checker | **Уникално — това е оръжието** |
+| **8.3** | ⏳ Concurrency (tasks + channels) | Go-стил леки нишки |
+| **8.4** | ⏳ CTFE (`const func`) | Nim-level метапрограмиране |
+| **8.5** | ⏳ Trait система | Rust-стил генерици |
+| **8.6** | ⏳ Макроси | Nim-стил метапрограмиране |
+| **8.7** | ⏳ LSP сървър | IDE поддръжка |
+
+---
+
+## Target аудитория
+
+1. **C програмисти** искащи по-добър tooling → Bux дава типове, генерици, pattern matching без GC
+2. **Nim програмисти** искащи C-like синтаксис → Bux има същата скорост, по-познат syntax
+3. **Rust програмисти** уморени от borrow checker → Bux дава safety само където трябва
+4. **Нови програмисти** → Bux е по-прост от Rust, по-строг от Python
+
+---
+
+## Рискове
+
+| Риск | Вероятност | Митигация |
+|------|------------|-----------|
+| Borrow checker твърде сложен за имплементация | Средна | Започваме с basic: само `&T` и `&mut T`, без lifetimes |
+| Няма достатъчно ecosystem | Висока | Първо self-hosting, после пакети |
+| Няма corporate backing | Висока | Open-source community подход |
+| C backend ограничава производителността | Ниска | C компилаторите са 30+ години оптимизирани |
+
+---
+
+## Заключение
+
+**Bux не трябва да е "по-добър Rust" или "по-добър Nim".** Той трябва да е **единственият език с gradual safety** — бърз за писане като C, безопасен като Rust, но само където програмистът избере.
+
+Това е празна ниша на пазара. Никой не я запълва. Bux може да е първият.