160 lines
7.1 KiB
Markdown
160 lines
7.1 KiB
Markdown
# Как 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 може да е първият. |