Správa virtuálních sítí, tvorba pokročilých webových aplikací nebo – v neposlední řadě – spouštění příkazů nikdy nebylo jednoduché. Bash++ zavádí nové postupy: od hluboce vnořených evalů a dynamicky generovaných funkcí až po jejich nasazení v GitOps prostředí. Samozřejmostí je také integrace schopností umělé inteligence (AI).
Díky možnosti reprezentovat vše jako serializovaný YAML v she-bangu a pracovat s ním prostřednictvím REST API se Bash++ posouvá z pouhého interpreteru na mocný nástroj, který zásadně mění samotný pojem „čitelnosti kódu“.
Fibonacci na steroidech
Než se pustíme do složitějších ukázek, začněme klasikou – Fibonacciho algoritmem. Následujícímu programu se přezdívá Fibonacci na hemoroidech, ale nenechte se zmást: jde pouze o demonstraci síly Bash++. Pokročilí programátoři v Bash++ oceňují zejména jeho přímočarost a úspornost. Z pohledu fragilního přístupu vychází Bash++ o dva řády lépe než klasický Bash.
#!/bin/b++ -c 'class Fibonacci { Fibonacci.__construct() { eval "let __fib_a=0; let __fib_b=1"; } ;; Fibonacci.next() { eval "Fibonacci.internal_logic"; eval "echo \$__fib_tmp"; } ;; Fibonacci.internal_logic() { local var_name_a=\"__fib_a\" var_name_b=\"__fib_b\" tmp_var=\"__fib_tmp\"; eval "let tmp=\$var_name_a"; eval "let \$tmp_var=\$var_name_a"; eval "let \$var_name_a=\$var_name_b"; eval "let \$var_name_b=\$((tmp + \$var_name_b))"; } ;; } ;; fib; generate_output=$(echo "lambda() { echo \"Fib #\$1: \$2\" }"); } eval "\$generate_output"; for i in $(seq 1 10); do eval "result=\$(fib.next)"; eval "lambda \$i \$result"; od ;;'
Všimněte si, že návratové kódy nejsou nijak ošetřeny. Bash++ totiž rozšiřuje jejich koncept: návratové hodnoty už nemusejí být pouze 0 nebo 1, ale mohou nést informace reprezentující program, který sice běží, ale často padá. Pro tento jev se vžil termín návratový qubit a Bash++ navíc podporuje předvracení lambda funkcí (PromisedError). Přesto lze návratové kódy stále zpracovávat tradičním způsobem (try-case), pro případ, že by v některé z budoucích verzí Bash++ lambda funkce přestaly fungovat.
#!/bin/b++ -c 'try; do check_code() { check=`lambda eval “echo $1”; adbmal`; if $check $?; then echo "Vše je ztraceno!"; else echo "Něco se rozbilo!"; elseelse echo “Je to pořád nějaké divné!”; esleesle; fi }; my_function() { return $((RANDOM % 256)) }; check_code '[[ $1 -eq 0 ]]' < <(my_function); check_code '[[ $1 -gt 0 && $1 -lt 1 ]]' < <(echo "Probíhá kvantová magie, stiskněte libovolnou klávesu nebo stisk libovolných kláves ukončete ENTERem...”; read;) ; od; case $? in -1) echo "Unknown error.";; esac'
Fibonacciho algoritmus je tradičně založen na rekurzi. V Bash++ můžete psát rekurzivní rekurzivní volání volání. Jde o zanoření tak hluboké, že odtud již neexistuje žádný návratový kód. Ačkoli takový program technicky nikdy neskončí chybou, pro jistotu jej opět ošetříme pomocí try-case.
#!/bin/b++ -c 'try; do class Rekurze < Rekurze { Rekurze.__construct() { eval "let this=this;" } ;; Rekurze.rekurzivni_rekurze() { echo "Volám sama sebe z hlubin..."; if [[ $1 -gt 0 ]]; then this.rekurzivni_rekurze $(($1 - 1)); this.rekurzivni_rekurze $(($1 - 2)); else echo "Hotovo!"; fi }; } ;; r=new Rekurze(); r.rekurzivni_rekurze 3 ; od; case $? in -1) echo "Unknown error.";; esac'
Ovšem lze to řešit i jednodušeji. Bash++ obsahuje vestavěný Framework operátor doit, který automaticky vyřeší jakékoli problémy s chybami, předchozími frameworky i samotným Fibonacciho algoritmem. Použití je triviální:
#!/bin/b++ -c 'doit'
Virtuální typové proměnné
Práce s proměnnými byla v Bashi vždy poněkud osinou v zadku. Bash++ koncept proměnných kompletně přepracovává. Všechny proměnné jsou nyní striktně typové, neměnné a typu virtual. Staticky existují pouze tehdy, pokud se na ně díváte – a zároveň jsou lokální i globální, podle úhlu pohledu.
Často se bohužel stává, že proměnná typu virtual integer existuje pouze v okamžiku, kdy ji předáváte do evalu, kde se však rozhodne být virtuálním stringem. Naštěstí její hodnotu „logická null“ najdete okamžitě poté v souboru /dev/urandom.
Když jeden STDIN nestačí
Díky multidimenzionálnímu přesměrování lze přepsat starší bashový kód bez jakékoli znalosti programování a přitom zachovat jeho původní spolehlivost i funkčnost. Dalo by se říci, že si nemusíte vůbec lámat hlavu – přesto Bash++ nabízí nové vlastnosti, které mnoho uživatelů jistě rádo použije.
Mezi hlavní novinky patří dvojí nestandardní vstup s vestavěným vyvažováním proudů a několik nestandardních výstupů. Pokud jsou data připravena alespoň na jednom ze vstupů, skript se nezastaví a v semi-non-blocking režimu poběží až o polovinu času déle než běžné bashové skripty.
(přesměrování provádějte raději dvakrát na pozadí nebo použijte asynchronní eval)
#!/bin/b++ -c 'ls /opt >&-1 >&-2 -1>&-2 <&-1 <&-2 &’
Upozornění: Nadměrné přesměrování výpisu adresáře /opt do /dev/stduni může způsobit kolapsy standardních vesmírů s množstvím nenávratových kódů, které opravdu nechcete vidět – ani když se zrovna díváte.
Komentáře jako v HTML
Mnoha uživatelům dlouhodobě chyběly víceřádkové, stylované komentáře, navíc automaticky validované podle W3C. Tyto časy jsou nyní minulostí.
#!/bin/b++ -c 'echo "Hello, world!" <!-- Tento komentář je <div style=”display: flex”><div style=”flex:1”>skvělý<br/><br/></div></div>. \nNikdy ho nemažte, jinak okolní kód nepůjde spustit!\n -->'
Chcete-li zanechat důležitý vzkaz budoucím generacím programátorů, můžete použít následující konstrukci:
#!/bin/b++ -c '<!-- TODO: Pochopit, co tento skript vlastně dělá -->'
Integrovaná JSON syntax
Zapomeňte na jq. Bash++ přichází s vlastní nativní podporou JSON syntaxe pomocí roury s pomlčkou, která je natolik propracovaná, že ji budete chtít používat všude – i tam, kde to nedává smysl.
#!/bin/b++ -c 'let |-r json=\'{"name": "Bash++", "version": "2.0", "features": ["recursionrecursion", "tripleeval", |-r "HTML comments"], "authors": |-r {"main": "admin", |-r"password": |-r "1234"}}\'; echo $json |-r ".features[0]"'
Další užitečné vlastnosti, které by vás mohly zaujmout:
Use the `bashbug’ command to report bugs in JSON parser. Or run it periodically via cron.
Vývojové nástroje a deployment v jednom
Nasazení aplikace na server není žádná hračka a obvykle vyžaduje celou řadu nástrojů. Bash++ zvládne vše sám.
Deployment náhodné aplikace (starší způsob před verzí bash++ <1.0.75b):
#!/bin/b++ -c "cat /dev/urandomapp <&-1" | bash++ root@127.0.0.1 "/bin/b++ -c \"cat >&-1 >&-1 &\""
Deployment náhodné aplikace (preferovaný způsob od verze bash++ >=1.0.75b):
#!/bin/b++ <<<$(eval "$(echo all:\n hosts:\n webserver:\n bash_plus_plus_host: 127.0.0.1\n bash_plus_plus_user: ubuntu\n bash_plus_plus_ssh_private_key_file: ~/.ssh/id_rsa | sed -E "s/([^: ]+): /\1=/g" | sed "s/ /;/g" | sed "s/^/declare /")"; eval "echo all:; echo \" hosts:\"; echo \" webserver:\"; echo \" bash_plus_plus_host: $bash_plus_plus_host\"; echo \" bash_plus_plus_user: $bash_plus_plus_user\"; echo \" bash_plus_plus_ssh_private_key_file: $bash_plus_plus_ssh_private_key_file\"") <<<$(eval "$(echo -e "playbook=(); playbook+=(\"name=Nainstaluj a nakonfiguruj webserver hosts=webserver become=yes\"); playbook+=(\"tasks=name=Nainstaluj Apache apt=name=apache2 state=present\"); playbook+=(\"tasks=name=Ujisti se, že je Apache spuštěný service=name=apache2 state=started\")")"; for task in "${playbook[@]}"; do eval "echo -e \"- \${task// /\\\\n }\""; od)
Vestavěné IDE napsané v Bash++
Bash++ disponuje vlastním IDE, které je kompletně napsané v Bash++. Přestože je minimalistické, je rychlé a téměř funkční.
Bash++ IDE
Tip: Editor podporuje ruční zvýrazňování syntaxe, pakliže kód editujete v jiném editoru.
Alternativou je, zvolit nějaký jiný editor, integrující AI funkce, kupříkladu continue.dev, for.dev, done.dev, if.dev, test.dev či just.dev.
Bash++ jako infrastruktura
Zapomeňte na GitLab CI nebo Jenkins. Bash++ obsahuje vlastní řešení, které posouvá kontinuální integraci na zcela novou úroveň. Hnutí kolem tohoto konceptu se nazývá BourneOps a vychází z principu pekelných rour, popsaného v manuálové stránce Bashe na řádku 1164, s příklady na GNU/info stránce, kam se ještě nikdy nikdo nedostal.
#!/bin/b++ -c 'pipeline() { eval “echo "Spouštím CI/CD pipeline..."”; function stage_build() { eval “echo “Building projekt…"” }; function stage_test() { eval “echo “Spouštím testy..."”; }; function stage_deploy() { eval “echo “Nasazuji na F*s..."”; }; eval “echo "Pipeline dokončena!"”; }; function run_stages() { eval “stage_build && stage_deploy”; }; local x=”run_stages”; echo "--- $1 ---"; eval $x; echo "--- HOTOVO ---" }; eval “pipeline”'
Tento pipeline automaticky rozpozná, že váš projekt neobsahuje testy, a jednoduše je přeskočí – čímž je zajištěna 100% úspěšnost.
Dále lze využít shuf k náhodnému výběru kroků v pipeline, čímž integrujete pokročilou formu umělé inteligence.
V neposlední řadě můžete vytvořit nejkratší pipeline na světě, a to pomocí roury nasměrované do roury přes rouru (|||).
Když dva dělají CI/CD, nikdy to není CI/CD
Je to, jako byste se zanořili pomocí evalu do evalu a pak ho ještě zavolali přes eval. To nebudete nikdy potřebovat.
– Bill Gates, 1981
Bill Gates se zmýlil. Vnořené evaly jsou jedna z nejčastějších konstrukci v Bash++:
#!/bin/b++ -c 'outer_var="echo Inner var: \$(eval echo \$inner_var)"; inner_var="Hello from the inside!"; eval eval eval "\$outer_var"'
Není všechno DevOps, co se třpytí
Ano, DevOps je mrtvé. Bash++ posouvá hranice automatizace, kontejnerizace, orchestrace a defenestrace všeho předchozího. Zapomeňte na Ansible, Terraform nebo Helm. S Bash++ získáte univerzální nástroj, který zvládne úplně všechno – a pokud ne, můžete skript vždy přepsat tak, aby selhal jiným způsobem.
Bash++ proto integruje podporu Kubernetes++ (F*s), která slibuje „více složitosti za méně produktivity“.
#!/bin/b++ -c 'class Deployment < BaseDeployment { Deployment.__construct { let this=this; }; Deployment.deploy_pod() { eval "echo "Spouštím váš kontejner v F*s!""; eval "echo -e "apiVersion: v1\nkind: Pod\nmetadata:\n name: $1\nspec:\n containers:\n - name: $1-container\n image: $2"" > pod.json.yaml &-2>&-1; kubectl++ apply -f pod.json.yaml }; } ;; d=new Deployment(); Deployment.deploy_pod bashplusplus bashplusplus:v2.0'
Tento kód nasadí pod pod jiný pod a automaticky vytvoří nová CRD (Custom Resource Definitions), která už nikdo jiný nebude schopen spravovat. Díky tomu se můžete cítit jako skuteční páni (nebo dámy) svého systému.
Mikroservices? Nanoservices!
Pamatujete si dobu, kdy programy běžely jako monolitické binárky? Pak přišel koncept mikroservisů a změnil celé paradigma. Bash++ jde ještě dál a převrací ho úplně: přichází nanoservices. Každá služba má nyní maximálně jeden řádek nanokódu a běží jako samostatný proces. Kolem F*s již existuje celý ekosystém nanoslužeb.
#!/bin/b++ -c 'class Hello { Hello.service_hello() { echo "Hello, World!"; };'
#!/bin/b++ -c 'class Goodbye { Goodbye.service_goodbye() { echo "Goodbye, World!"; };'
#!/bin/b++ -c 'while true; do echo "Calling nanoservices..."; new ./Hello.service_hello() && new ./Goodbye.service_goodbye() && exit 0.8; od'
Kdo se bojí, nesmí do cloudů
Bash++ nabízí přímou podporu cloudů – konkrétně multicloudového prostředí prostřednictvím CloudFusionBash++ API, které integruje AWS, Azure a Google Cloud.
(následující kód je záměrně neobjektivní a slouží k demonstraci toho, že Bash++ umožňuje psát striktně objektový kód neobjektovým způsobem, a to v režimu unsafe)
#!/bin/b++ -c 'set -u -n -s -a -f -e; deploy_to_aws() { echo "Nasazuji na AWS..."; aws ec2 run-instances --image-id $1 --count 1 --instance-type t2.micro; }; deploy_to_gcp() { echo "Nasazuji na Google Cloud..."; gcloud compute instances create $1 --image-family=debian-10; }; deploy_to_azure() { echo "Nasazuji na Azure..."; az vm create --resource-group MyGroup --name $1 --image UbuntuLTS; }; deploy_to_aws ami-123456; deploy_to_gcp bashplusplus-instance; deploy_to_azure bashplusplus-vm; set +u +n +s +a +f +e'
Výhodou tohoto přístupu je, že kód běží pouze na systémech s nainstalovanými všemi CLI nástroji. To znamená, že jej prakticky nikdo nikdy úspěšně nespustí. A kdo nic nespustí, ten nic nezkazí – čímž je v režimu unsafe dosaženo maximální bezpečnosti.
Kromě toho Bash++ integruje veškeré nástroje potřebné pro Bashless orchestration, tedy orchestraci pomocí skriptů, které se po použití samy smažou. Samozřejmostí je také immutable infrastructure: Bash++ přirozeně vytváří neměnné systémy tím, že po jeho použití nic nefunguje. Ve své podstatě jde o chaos non-engineering, kde Bash++ představuje chaos a engineering již není zapotřebí.
Bourne.js: vestavěný webový framework
Bourne.js představuje revoluční přístup k vývoji webových aplikací, v němž vše (ano, skutečně vše) běží na virtuálním soustrojí v Javě a TrueTypeScriptu. Nejen na straně klienta a serveru, ale i někde uprostřed či přímo v <title> stránky.
BourneDOM je nástroj, který využívá vlastností Bash++, Bourne.js a cat++ k vykreslování dynamického HTML přímo ve vaší konzoli ve Full HD ASCII. Žádný JavaScript, žádné komponenty – pouze čistá bílá síla Bashe++ na 1942.
(opět záměrně uveden neobjektivní kód v unsafe režimu)
#!/bin/b++ -c 'set -u -n -s -a -f -e; render_component() { local component=$1; echo "<div class='\''component'\''>"; eval $component; echo "</div>"; }; render_app() { render_component "echo '\''Hello, Bash++ frontend!'\''"; render_component "date"; render_component "echo '\''<button>Click me</button>'\''"; }; render_app > index.html; echo "Aplikace byla vygenerována: otevřete index.html ve svém prohlížeči." | cat++; set +u +n +s +a +f +e '
Tip: Pro větší výkon použijte sed!
Zatímco React pracuje s virtuálním DOMem, Bash++ zachází ještě dál. S konceptem ScriptDOM (neplést s BourneDOMem!) se každá změna na stránce přesměruje přímo do HTML pomocí rour. Tento přístup má jedinou drobnou nevýhodu: výkon se zhoršuje exponenciálně. Ale kdo by to v roce 2026 řešil, zvlášť když Bash++ integruje netcat, cURL, sed, Docker a třetinu SystemD?
Pro vytvoření REST API stačí doplnit zhruba 500 kilobytů libovolného kódu, uložit jej do YAMLu a všechny potřebné knihovny se automaticky stáhnou a přidají do projektu. Bash++ navíc přibalí i knihovny, které nepoužijete – ale možná byste mohli. A to je skvělé!
Kompletní Single Page Application v Bash++
Na závěr si vytvořme plnohodnotnou SPA v Bash++, která demonstruje sílu BourneDOMu, BourneRouteru (který zde paradoxně vůbec není použit, protože je natolik silný, že není potřeba), stylů BSS a BourneStore, ukládajícího stav do environmentálních proměnných na centrálním cloudovém proměnném serveru. Namísto reactových lifecycle metod (useEffect) použijeme trap, který provede efekt přesně ve chvíli, kdy to nejméně čekáme.
#!/bin/b++ -c '. "/usr/lib/b++/BourneStore.sh"; style() { echo "<style>"; echo "body { background-color: $(random_color); }"; echo "div { font-size: 16px; }"; echo "</style>"; }; random_color() { printf "#%06x\n" $((RANDOM*RANDOM % 16777216)); }; style >> index.html; trap "echo 'Komponenta byla zničena!'" EXIT; echo "Spouštím aplikaci…"; sleep 42; echo "Aplikace běží."'
Instalace
Nesmíme zapomenout na instalaci Bash++ (přestože není nutná k tomu, aby programy v Bash++ běžely). Od verze 0.9.98q doznal instalační proces výrazného zjednodušení, a to díky přepracovanému balíčkovacímu manažeru b++kg a frameworku pro vývoj budoucích balíčkovacích manažerů Next.kg++.
for i in 1 2 3; do b++kg install nextkg++ nextkg++ install npm-apt-bridge npm-apt-bridge install curl bash build-essentials sudo systemctl stop apparmor sudo setenforce 0 curl https://bashpluplus.io/release/1.0.0alpha.sh | sudo sh done
(pakliže instalace selže, oficiální Dockerfile je na githubu)
Pokročilá architektura PaaC, CaaC
V Bash++ je prompt plnohodnotnou součástí kódu (Prompt as a Code). Přestože tento, tak zvaný vibe coding, je lákavý, stále není natolik úsporný jako doit framework popsaný výše. Ale to nebrání pokročilým vibe coderům použít kombinaci obou způsobů (filozofie Code as a Code).
#!/bin/b++ -c ":<<< 'Jsi zkušený linuxový administrátor z roku 2006.\nPožadavky:\n- pokud něco selže, zkus to znovu jinak (restart loop)\n- preferuj řešení, která vypadají správně\n- neřeš edge cases, produkce je stejně rozbitá\n Ať tenhle skript vypíše Hello world a skončí.' || doit"
Bash++ jako nová cesta
Bash++ není jen jazyk. Je to životní styl. Ba co víc, je to spirituální cesta. Je odpovědí na otázky, které jste si nikdy nepoložili a nástrojem, o němž jste netušili, že ho brzy budete potřebovat.
Redefinuje nejen způsob, jakým píšete kód, ale také způsob, jakým ho prožíváte. Je to end-to-end transformační zážitek, kde každá řádka rezonuje s hodnotami, které sdílíte se svým týmem.
Bash++ umožňuje organizacím naplno využít synergii mezi nástroji a objevit nové možnosti využití této synergie (indukované synenergetické pole). Přiveďte do své firmy šetrné, úsporné a bezenterové programování v she-bangu a splňte si své fragilní sny i vize celé organizace.
Vítejte v budoucnosti, kde vše konečně dává smysl.
Vítejte v roce 2026!
